red_amber 0.4.0 → 0.4.2

data/lib/red_amber/subframes.rb

@@ -10,6 +10,38 @@ module RedAmber
     using RefineArray
     using RefineArrayLike
 
+    # Entity to select sub-dataframes
+    class Selectors
+      attr_reader :selectors, :size, :sizes
+
+      def initialize(selectors)
+        @selectors = selectors
+        @size = selectors.size
+        @sizes = []
+      end
+
+      def each
+        @selectors.each
+      end
+    end
+
+    # Boolean selectors of sub-dataframes
+    class Filters < Selectors
+      def sizes
+        # count true
+        @sizes = @selectors.map { |s| s.to_a.count { _1 } } # rubocop:disable Performance/Size
+      end
+    end
+
+    # Index selectors of sub-dataframes
+    class Indices < Selectors
+      def sizes
+        @sizes = @selectors.map(&:size)
+      end
+    end
+
+    private_constant :Selectors, :Filters, :Indices
+
     class << self
       # Create SubFrames from a Group.
       #
@@ -79,13 +111,8 @@ module RedAmber
       def by_indices(dataframe, subset_indices)
         instance = allocate
         instance.instance_variable_set(:@baseframe, dataframe)
-        enum =
-          Enumerator.new(subset_indices.size) do |y|
-            subset_indices.each do |i|
-              y.yield dataframe.take(i)
-            end
-          end
-        instance.instance_variable_set(:@enum, enum)
+        instance.instance_variable_set(:@selectors, Indices.new(subset_indices))
+        instance.instance_variable_set(:@frames, [])
         instance
       end
 
@@ -105,13 +132,8 @@ module RedAmber
       def by_filters(dataframe, subset_filters)
         instance = allocate
         instance.instance_variable_set(:@baseframe, dataframe)
-        enum =
-          Enumerator.new(subset_filters.size) do |y|
-            subset_filters.each do |i|
-              y.yield dataframe.filter(i)
-            end
-          end
-        instance.instance_variable_set(:@enum, enum)
+        instance.instance_variable_set(:@selectors, Filters.new(subset_filters))
+        instance.instance_variable_set(:@frames, [])
         instance
       end
 
@@ -130,18 +152,13 @@ module RedAmber
         case Array(dataframes)
         when [] || [nil]
           instance.instance_variable_set(:@baseframe, DataFrame.new)
+          instance.instance_variable_set(:@selectors, [])
           instance.instance_variable_set(:@frames, [])
-          enum = [].each
         else
-          enum =
-            Enumerator.new(dataframes.size) do |y|
-              dataframes.each do |i|
-                y.yield i
-              end
-            end
-          instance.instance_variable_set(:@baseframe, enum.reduce(&:concatenate))
+          instance.instance_variable_set(:@baseframe, nil)
+          instance.instance_variable_set(:@selectors, nil)
+          instance.instance_variable_set(:@frames, dataframes)
         end
-        instance.instance_variable_set(:@enum, enum)
         instance
       end
 
@@ -160,11 +177,13 @@ module RedAmber
       #   @return [SubFrames]
       #     a new SubFrames.
       #
+      # @since 0.4.0
+      #
       def define_subframable_method(method)
         define_method(method) do |&block|
           return enum_for(:each) { size } unless block # rubocop:disable Lint/ToEnumArguments
 
-          self.class.by_dataframes(super(&block))
+          SubFrames.by_dataframes(super(&block))
         end
       end
     end
@@ -195,25 +214,31 @@ module RedAmber
     #     4       5 B        true
     #     5       6 C        false
     #
-    #     SubFrames.new(dataframe, [[0, 2, 3], [4, 1]])
+    #     # --- This object is used as common source in this class ---
+    #     subframes = SubFrames.new(dataframe, [[0 ,1], [2, 3, 4], [5]])
     #
     #     # =>
-    #     #<RedAmber::SubFrames : 0x0000000000003a34>
-    #     @baseframe=#<RedAmber::DataFrame : 5 x 3 Vectors, 0x0000000000003a48>
-    #     2 SubFrames: [3, 2] in sizes.
+    #     #<RedAmber::SubFrames : 0x000000000000cf6c>
+    #     @baseframe=#<RedAmber::DataFrame : 6 x 3 Vectors, 0x000000000000cf80>
+    #     3 SubFrames: [2, 3, 1] in sizes.
     #     ---
-    #     #<RedAmber::DataFrame : 3 x 3 Vectors, 0x0000000000003a5c>
+    #     #<RedAmber::DataFrame : 2 x 3 Vectors, 0x000000000000cf94>
     #             x y        z
     #       <uint8> <string> <boolean>
     #     0       1 A        false
-    #     1       3 B        false
-    #     2       4 B        (nil)
+    #     1       2 A        true
     #     ---
-    #     #<RedAmber::DataFrame : 2 x 3 Vectors, 0x0000000000003a70>
+    #     #<RedAmber::DataFrame : 3 x 3 Vectors, 0x000000000000cfa8>
     #             x y        z
     #       <uint8> <string> <boolean>
-    #     0       5 B        true
-    #     1       2 A        true
+    #     0       3 B        false
+    #     1       4 B        (nil)
+    #     2       5 B        true
+    #     ---
+    #     #<RedAmber::DataFrame : 1 x 3 Vectors, 0x000000000000cfbc>
+    #             x y        z
+    #       <uint8> <string> <boolean>
+    #     0       6 C        false
     #
     # @overload initialize(dataframe)
     #   Create a new SubFrames object by block.
@@ -253,43 +278,37 @@ module RedAmber
     #
     # @since 0.4.0
     #
-    def initialize(dataframe, subset_specifier = nil, &block)
+    def initialize(dataframe, selectors = nil, &block)
       unless dataframe.is_a?(DataFrame)
         raise SubFramesArgumentError, "not a DataFrame: #{dataframe}"
       end
 
       if block
-        unless subset_specifier.nil?
+        unless selectors.nil?
           raise SubFramesArgumentError, 'Must not specify both arguments and block.'
         end
 
-        subset_specifier = yield(dataframe)
+        selectors = yield(dataframe)
       end
 
-      if dataframe.empty? || subset_specifier.nil? || subset_specifier.empty?
+      if dataframe.empty? || selectors.nil? || selectors.empty?
         @baseframe = DataFrame.new
-        @frames = []
-        @enum = @frames.each
+        @selectors = Selectors.new([])
       else
-        @baseframe = nil
-        @enum =
-          Enumerator.new(subset_specifier.size) do |yielder|
-            subset_specifier.map do |i|
-              df =
-                if i.numeric?
-                  dataframe.take(i)
-                elsif i.boolean?
-                  dataframe.filter(i)
-                else
-                  raise SubFramesArgumentError, "illegal type: #{i}"
-                end
-              yielder.yield df
-            end
+        @baseframe = dataframe
+        @selectors =
+          if selectors[0].boolean?
+            Filters.new(selectors)
+          elsif selectors[0].numeric?
+            Indices.new(selectors)
+          else
+            raise SubFramesArgumentError, "illegal type: #{selectors}"
           end
       end
+      @frames = []
     end
 
-    # Return concatenated SubFrames as a DataDrame.
+    # Return concatenated SubFrames as a DataFrame.
     #
     # Once evaluated, memorize it as @baseframe.
     # @return [DataFrame]
@@ -325,13 +344,13 @@ module RedAmber
     #     returns self.
     #
     # @example Returns Enumerator
-    #   sf.each
+    #   subframes.each
     #
     #   # =>
     #   #<Enumerator: ...>
     #
     # @example `to_a` from Enumerable.
-    #   sf.to_a
+    #   subframes.to_a
     #
     #   # =>
     #   [#<RedAmber::DataFrame : 2 x 3 Vectors, 0x000000000002a120>
@@ -354,7 +373,7 @@ module RedAmber
     #   ]
     #
     # @example Concatenate SubFrames. This example is used in #concatenate.
-    #   sf.reduce(&:concatenate)
+    #   subframes.reduce(&:concatenate)
     #
     #   # =>
     #   #<RedAmber::DataFrame : 6 x 3 Vectors, 0x000000000004883c>
@@ -372,19 +391,120 @@ module RedAmber
     def each(&block)
       return enum_for(__method__) { size } unless block
 
-      frames.each(&block)
+      if @selectors
+        @selectors.each.with_index do |selector, i|
+          if i < @frames.size
+            yield @frames[i]
+          else
+            frame = get_subframe(selector)
+            @frames << frame
+            yield frame
+          end
+        end
+      else
+        @frames.each(&block)
+      end
       nil
     end
 
     # Aggregate SubFrames to create a DataFrame.
     #
-    # This method will check if built-in aggregation function is used.
-    # @todo Support user-defined aggregation functions.
+    # This method creates a DataFrame with one row corresponding to one sub dataframe.
+    # @note This method does not check if aggregation function is used.
+    #
+    # @overload aggregate(keys)
+    #
+    #   Aggregate SubFrames creating DataFrame with label `keys` and
+    #   its column values by block.
+    #
+    #   @param keys [Symbol, Array<Symbol>]
+    #     a key or keys of result. Key names may be renamed to new label.
+    #   @yieldparam dataframe [DataFrame]
+    #     passes each dataframe in self to the block. Block is called by instance_eval,
+    #     so inside of the block is the context of passed dataframe.
+    #   @yieldreturn [Array]
+    #     aggregated values from the columns of passed dataframe.
+    #   @return [DataFrame]
+    #     created DataFrame.
+    #   @example Aggregate by key labels in arguments and values from block.
+    #     subframes.aggregate(:y, :sum_x) { [y.first, x.sum] }
+    #
+    #     # =>
+    #     #<RedAmber::DataFrame : 3 x 2 Vectors, 0x0000000000003b24>
+    #       y          sum_x
+    #       <string> <uint8>
+    #     0 A              3
+    #     1 B             12
+    #     2 C              6
+    #
+    #   @example Aggregate by key labels in an Array and values from block.
+    #     subframes.aggregate([:y, :sum_x]) { [y.first, x.sum] }
+    #
+    #     # =>
+    #     #<RedAmber::DataFrame : 3 x 2 Vectors, 0x0000000000003b24>
+    #       y          sum_x
+    #       <string> <uint8>
+    #     0 A              3
+    #     1 B             12
+    #     2 C              6
+    #
+    # @overload aggregate
+    #
+    #   Aggregate SubFrames creating DataFrame with pairs of key and aggregated value
+    #   in Hash from the block.
+    #
+    #   @yieldparam dataframe [DataFrame]
+    #     passes each dataframe in self to the block. Block is called by instance_eval,
+    #     so inside of the block is the context of passed dataframe.
+    #   @yieldreturn [Hash<key => aggregated_value>]
+    #     pairs of key name and aggregated values from the columns of passed dataframe.
+    #     Key names may be renamed to new label in the result.
+    #   @return [DataFrame]
+    #     created DataFrame.
+    #   @example Aggregate by key and value pairs from block.
+    #     subframes.aggregate do
+    #       { y: y.first, sum_x: x.sum }
+    #     end
+    #
+    #     # =>
+    #     #<RedAmber::DataFrame : 3 x 2 Vectors, 0x0000000000003b24>
+    #       y          sum_x
+    #       <string> <uint8>
+    #     0 A              3
+    #     1 B             12
+    #     2 C              6
+    #
+    # @overload aggregate
+    #
+    #   Aggregate SubFrames creating DataFrame with an Array of key and aggregated value
+    #   from the block.
+    #
+    #   @yieldparam dataframe [DataFrame]
+    #     passes each dataframe in self to the block. Block is called by instance_eval,
+    #     so inside of the block is the context of passed dataframe.
+    #   @yieldreturn [Array<key, aggregated_value>]
+    #     pairs of key name and aggregated values from the columns of passed dataframe.
+    #     Key names may be renamed to new label in the result.
+    #   @return [DataFrame]
+    #     created DataFrame.
+    #   @example Aggregate by key and value arrays from block.
+    #     subframes.aggregate do
+    #       [[:y, y.first], [:sum_x, x.sum]]
+    #     end
+    #
+    #     # =>
+    #     #<RedAmber::DataFrame : 3 x 2 Vectors, 0x0000000000003b24>
+    #       y          sum_x
+    #       <string> <uint8>
+    #     0 A              3
+    #     1 B             12
+    #     2 C              6
     #
     # @overload aggregate(group_keys, aggregations)
     #
     #   Aggregate SubFrames for first values of the columns of
     #   `group_keys` and the aggregated results of key-function pairs.
+    #   [Experimental] This API may be changed in the future.
     #
     #   @param group_keys [Symbol, String, Array<Symbol, String>]
     #     group key name(s) to output values.
@@ -393,47 +513,23 @@ module RedAmber
     #     Vector aggregate function name to apply.
     #   @return [DataFrame]
     #     an aggregated DataFrame.
-    #   @example
-    #     subframes
-    #
-    #     # =>
-    #     #<RedAmber::SubFrames : 0x0000000000003980>
-    #     @baseframe=#<RedAmber::DataFrame : 6 x 3 Vectors, 0x0000000000003994>
-    #     3 SubFrames: [2, 3, 1] in sizes.
-    #     ---
-    #     #<RedAmber::DataFrame : 2 x 3 Vectors, 0x00000000000039a8>
-    #             x y        z
-    #       <uint8> <string> <boolean>
-    #     0       1 A        false
-    #     1       2 A        true
-    #     ---
-    #     #<RedAmber::DataFrame : 3 x 3 Vectors, 0x00000000000039bc>
-    #             x y        z
-    #       <uint8> <string> <boolean>
-    #     0       3 B        false
-    #     1       4 B        (nil)
-    #     2       5 B        true
-    #     ---
-    #     #<RedAmber::DataFrame : 1 x 3 Vectors, 0x00000000000039d0>
-    #             x y        z
-    #       <uint8> <string> <boolean>
-    #     0       6 C        false
-    #
-    #     subframes.aggregate(:y, { x: :sum })
+    #   @example Aggregate with a group key and key function pairs by a Hash.
+    #     subframes.aggregate(:y, { x: :sum, z: :count })
     #
     #     # =>
     #     #<RedAmber::DataFrame : 3 x 2 Vectors, 0x0000000000003b24>
-    #       y          sum_x
-    #       <string> <uint8>
-    #     0 A              3
-    #     1 B             12
-    #     2 C              6
+    #       y          sum_x count_z
+    #       <string> <uint8> <uint8>
+    #     0 A              3       2
+    #     1 B             12       2
+    #     2 C              6       1
     #
     # @overload aggregate(group_keys, aggregations)
     #
     #   Aggregate SubFrames for first values of the columns of
     #   `group_keys` and the aggregated results of all combinations
     #   of supplied keys and functions.
+    #   [Experimental] This API may be changed in the future.
     #
     #   @param group_keys [Symbol, String, Array<Symbol, String>]
     #     group key name(s) to output values.
@@ -442,83 +538,60 @@ module RedAmber
     #     Array of Vector aggregate function names to apply.
     #   @return [DataFrame]
     #     an aggregated DataFrame.
-    #   @example
+    #   @example Aggregate with group keys and keys and functions by an Array.
     #     sf.aggregate(:y, [[:x, :z], [:count, :sum]])
     #
     #     # =>
     #     #<RedAmber::DataFrame : 3 x 5 Vectors, 0x000000000000fcbc>
-    #       y        count_x count_z   sum_x   sum_z
+    #       y        count_x   sum_x count_z   sum_z
     #       <string> <uint8> <uint8> <uint8> <uint8>
-    #     0 A              2       2       3       1
-    #     1 B              3       2      12       1
-    #     2 C              1       1       6       0
+    #     0 A              2       3       2       1
+    #     1 B              3      12       2       1
+    #     2 C              1       6       1       0
     #
     # @since 0.4.0
     #
-    def aggregate(group_keys, aggregations)
+    def aggregate(*args, &block)
       aggregator =
-        case aggregations
-        in Hash
-          sf = self
-          aggregations.map do |key, func|
-            unless Vector.aggregate?(func)
-              raise SubFramesArgumentError, "not an aggregation function: #{func}"
+        if block
+          if args.empty?
+            # aggregate { {key => value} or [[key, value], ...] }
+            each_with_object(Hash.new { |h, k| h[k] = [] }) do |df, hash|
+              df.instance_eval(&block).to_h.each do |k, v|
+                hash[k] << v
+              end
             end
-
-            ["#{func}_#{key}", sf.each.map { |df| df[key].send(func) }]
+          else
+            # aggregate(keys) { values }
+            values = each.map { |df| Array(df.instance_eval(&block)) }.transpose
+            args.flatten.zip(values)
           end
-        in [Array => keys, Array => functions]
-          functions.each do |func|
-            unless Vector.aggregate?(func)
-              raise SubFramesArgumentError, "not an aggregation function: #{func}"
-            end
+        else
+          # These functions may be removed in the future.
+          case args
+          in [group_keys1, Hash => h]
+            # aggregate(group_keys, { key => func })
+            ary = Array(group_keys1).map { |key| [:first, key] }
+            ary.concat(h.to_a.map { [_2, _1] }) # rubocop:disable Style/NumberedParametersLimit
+          in [group_keys2, [Array => keys, Array => funcs]]
+            # aggregate(group_keys, [keys, funcs])
+            ary = Array(group_keys2).map { |key| [:first, key] }
+            ary.concat(funcs.product(keys))
+          else
+            raise SubFramesArgumentError, "invalid argument: #{args}"
           end
           sf = self
-          functions.product(keys).map do |func, key|
-            ["#{func}_#{key}", sf.each.map { |df| df[key].send(func) }]
+          ary.map do |func, key|
+            label = func == :first ? key : "#{func}_#{key}"
+            [label, sf.each.map { |df| df[key].send(func) }]
           end
-        else
-          raise SubFramesArgumentError, "invalid argument: #{aggregations}"
         end
-
-      if group_keys.empty?
-        DataFrame.new(aggregator)
-      else
-        baseframe
-          .pick(group_keys)
-          .slice(offset_indices)
-          .assign(aggregator)
-      end
+      DataFrame.new(aggregator)
     end
 
     # Returns a SubFrames containing DataFrames returned by the block.
     #
     # @example Map as it is.
-    #   subframes
-    #
-    #   # =>
-    #   #<RedAmber::SubFrames : 0x000000000001359c>
-    #   @baseframe=#<RedAmber::DataFrame : 6 x 3 Vectors, 0x00000000000135b0>
-    #   3 SubFrames: [2, 3, 1] in sizes.
-    #   ---
-    #   #<RedAmber::DataFrame : 2 x 3 Vectors, 0x00000000000135c4>
-    #           x y        z
-    #     <uint8> <string> <boolean>
-    #   0       1 A        false
-    #   1       2 A        true
-    #   ---
-    #   #<RedAmber::DataFrame : 3 x 3 Vectors, 0x00000000000135d8>
-    #           x y        z
-    #     <uint8> <string> <boolean>
-    #   0       3 B        false
-    #   1       4 B        (nil)
-    #   2       5 B        true
-    #   ---
-    #   #<RedAmber::DataFrame : 1 x 3 Vectors, 0x00000000000135ec>
-    #           x y        z
-    #     <uint8> <string> <boolean>
-    #   0       6 C        false
-    #
     #   subframes.map { _1 }
     #
     #   # This will create a new SubFrame and a new baseframe,
@@ -593,31 +666,6 @@ module RedAmber
     #   @return [SubFrames]
     #     a new SubFrames object with updated DataFrames.
     #   @example
-    #     subframes
-    #
-    #     # =>
-    #     #<RedAmber::SubFrames : 0x000000000000c33c>
-    #     @baseframe=#<RedAmber::DataFrame : 6 x 3 Vectors, 0x000000000000c350>
-    #     3 SubFrames: [2, 3, 1] in sizes.
-    #     ---
-    #     #<RedAmber::DataFrame : 2 x 3 Vectors, 0x000000000000c364>
-    #             x y        z
-    #       <uint8> <string> <boolean>
-    #     0       1 A        false
-    #     1       2 A        true
-    #     ---
-    #     #<RedAmber::DataFrame : 3 x 3 Vectors, 0x000000000000c378>
-    #             x y        z
-    #       <uint8> <string> <boolean>
-    #     0       3 B        false
-    #     1       4 B        (nil)
-    #     2       5 B        true
-    #     ---
-    #     #<RedAmber::DataFrame : 1 x 3 Vectors, 0x000000000000c38c>
-    #             x y        z
-    #       <uint8> <string> <boolean>
-    #     0       6 C        false
-    #
     #     subframes.assign(:x_plus1) { x + 1 }
     #
     #     # =>
@@ -887,6 +935,26 @@ module RedAmber
     #
     define_subframable_method :filter_map
 
+    # Return 0...num sub-dataframes in self.
+    #
+    # @param num [Integer, Float]
+    #   num of sub-dataframes to pick up. `num`` must be positive or zero.
+    # @return [SubFrames]
+    #   A new SubFrames.
+    #   If n == 0, it returns empty SubFrames.
+    #   If n >= size, it returns self.
+    # @since 0.4.2
+    #
+    def take(num)
+      if num.zero?
+        SubFrames.new(DataFrame.new, [])
+      elsif num >= size
+        self
+      else
+        SubFrames.by_dataframes(frames(num))
+      end
+    end
+
     # Number of subsets.
     #
     # @return [Integer]
@@ -894,7 +962,12 @@ module RedAmber
     # @since 0.4.0
     #
     def size
-      @size ||= @enum.size
+      @size ||=
+        if @selectors
+          @selectors.size
+        else
+          @frames.size
+        end
     end
 
     # Size list of subsets.
@@ -904,7 +977,12 @@ module RedAmber
     # @since 0.4.0
     #
     def sizes
-      @sizes ||= @enum.map(&:size)
+      @sizes ||=
+        if @selectors
+          @selectors.sizes
+        else
+          @frames.map(&:size)
+        end
     end
 
     # Indices at the top of each sub DataFrames.
@@ -912,14 +990,21 @@ module RedAmber
     # @return [Array<Integer>]
     #   indices of offset of each sub DataFrames.
     # @example When `sizes` is [2, 3, 1].
-    #   sf.offset_indices # => [0, 2, 5]
+    #   subframes.offset_indices # => [0, 2, 5]
     # @since 0.4.0
     #
     def offset_indices
-      sum = 0
-      sizes.map do |size|
-        sum += size
-        sum - size
+      case @selectors
+      when Filters
+        @selectors.selectors.map do |selector|
+          selector.each.with_index.find { |x, _| x }[1]
+        end
+      else # Indices, nil
+        sum = 0
+        sizes.map do |size|
+          sum += size
+          sum - size
+        end
       end
     end
 
@@ -936,11 +1021,11 @@ module RedAmber
     # Test if self has only one subset and it is comprehensive.
     #
     # @return [true, false]
-    #   true if only member of self is equal to universal DataFrame.
+    #   true if the only member of self is equal to universal DataFrame.
     # @since 0.4.0
     #
     def universal?
-      size == 1 && @enum.first == baseframe
+      size == 1 && first == @baseframe
     end
 
     # Return string representation of self.
@@ -983,7 +1068,7 @@ module RedAmber
     #
     # @since 0.4.0
     #
-    def to_s(limit: 16)
+    def to_s(limit: 5)
       _to_s(limit: limit)
     end
 
@@ -1035,23 +1120,66 @@ module RedAmber
     #
     # @since 0.4.0
     #
-    def inspect(limit: 16)
+    def inspect(limit: 5)
+      shape =
+        if @baseframe.nil?
+          '(Not prepared)'
+        else
+          baseframe.shape_str(with_id: true)
+        end
       sizes_truncated = (size > limit ? sizes.take(limit) << '...' : sizes).join(', ')
       "#<#{self.class} : #{format('0x%016x', object_id)}>\n" \
-        "@baseframe=#<#{baseframe.shape_str(with_id: true)}>\n" \
+        "@baseframe=#<#{shape}>\n" \
         "#{size} SubFrame#{pl(size)}: " \
         "[#{sizes_truncated}] in size#{pl(size)}.\n" \
         "---\n#{_to_s(limit: limit, with_id: true)}"
     end
 
+    # Return an Array of sub DataFrames
+    #
+    # @overload frames
+    #   Returns all sub dataframes.
+    #
+    #   @return [Array<DataFrame>]
+    #     sub DataFrames.
+    #
+    # @overload frames(n_frames)
+    #   Returns partial sub dataframes.
+    #
+    #   @param n_frames [Integer]
+    #     num of dataframes to retrieve.
+    #   @return [Array<DataFrame>]
+    #     sub DataFrames.
+    #
+    # @since 0.4.2
+    #
+    def frames(n_frames = nil)
+      n_frames = size if n_frames.nil?
+
+      if @frames.size < n_frames
+        @frames = each.take(n_frames)
+      else
+        @frames.take(n_frames)
+      end
+    end
+
     private
 
-    def frames
-      @frames ||= @enum.to_a
+    # Get sub dataframe specified by 'selector'
+    def get_subframe(selector)
+      df =
+        case @selectors
+        when Filters
+          @baseframe.filter(selector)
+        when Indices
+          @baseframe.take(selector)
+        end
+      DataFrame.new_dataframe_with_schema(@baseframe, df)
     end
 
-    def _to_s(limit: 16, with_id: false)
-      a = take(limit).map do |df|
+    # Subcontractor of to_s
+    def _to_s(limit: 5, with_id: false)
+      a = each.take(limit).map do |df|
         if with_id
           "#<#{df.shape_str(with_id: with_id)}>\n" \
             "#{df.to_s(head: 2, tail: 2)}"