namo 0.9.2 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2959666eaa2d603b1877d42863ddadae9e021aceb753a60009579a2dbe2d7aa4
-  data.tar.gz: ac865863705a2ca58c815eed073227a39ebb479358fea0590e4f76a5f6b0813c
+  metadata.gz: 40c2256efac2663b7593bb1f7e4c3ca08fa07e6e225c75fcef3d6d8658f3794b
+  data.tar.gz: abd7bd9076d7019c245d942425232dcf0966edb076cf6d50fdedf7b74efea90f
 SHA512:
-  metadata.gz: '09cc42eba9f306b4316a70140bb9642dc025c39d4bc3a502b21bee28058709b8b55609093d9979e27e2799d1bdad1efd60d829a71931502abc8e7cde71f1a1c7'
-  data.tar.gz: 3952f6470d2f5dc8aeb733034d8c7cbf6214b909453f3b26e7ac29480388b79d345efba1ff925ce4617c64c7a9c2f1e578f2e8938f2e51def0d378109f65d276
+  metadata.gz: 2b5045c4160d8812fa3f04f10dc027bf8c6cfaf937405cec0570a31af52babdc1f2dc6e25db249a9b9dea81afc9806f617203ae71dded576974fe9512bd4ec00
+  data.tar.gz: a553ef0ae27d67bf28d8d91ba9e2e71f217f8ee23ff3d177ad207dd520f30971730774a51660830d98d79a6189cee16f1227dbd168282f3a27c4316912a6f29f

data/CHANGELOG

@@ -1,6 +1,30 @@
 CHANGELOG
 _________
 
+20260531
+0.11.0: ~ Subset Enumerable methods (select, reject, sort_by, first, last, take, drop, take_while, drop_while, uniq, partition) return Namos
+
+1. + Namo#select, Namo#reject, Namo#sort_by, Namo#take_while, Namo#drop_while: Predicate and ordering subset methods that wrap the @data Array result in `self.class.new(..., formulae: @formulae.dup)`, shadowing Enumerable's Array-returning defaults. Blocks receive a Row, so formulae resolve inside the predicate, and formulae carry through to the returned Namo. Namo#select is aliased as filter and find_all (the only overridden method with Enumerable aliases), so the aliases return Namos too.
+2. + Namo#first, Namo#last: With an argument, return a Namo of the first/last n rows. Without an argument, return a single Row (or nil on an empty Namo), per Ruby's Enumerable#first / Array#last convention. first(0) returns an empty Namo (n is truthy). last(n) reads @data.last(n) directly — the efficient path, no Enumerable materialise-then-slice fall-through.
+3. + Namo#take, Namo#drop: Leading subset and its complement, wrapping @data.take(n) / @data.drop(n).
+4. + Namo#uniq: Full-row dedupe. The no-block path dedupes raw @data hashes via Array#uniq, which uses eql?/hash — matching Row#eql?/Row#hash from 0.10.0, so numeric types stay distinct ({n: 1} and {n: 1.0} are both kept) and Row allocations are avoided. With a block, dedupes on the block's return value, per Enumerable#uniq.
+5. + Namo#partition: Returns [Namo, Namo] — matches and non-matches — each wrapped via self.class.new with duped formulae. map, flat_map, reduce, sum, min_by, max_by, count, and each are deliberately left unchanged (transformed values, scalars, or already-correct). group_by is structurally blocked — it needs Namo::Collection (0.17.0) and lands at 0.18.0.
+6. ~ test/namo_test.rb: + describe blocks for each new method — return-as-Namo, formula references in blocks, formula carry-through, empty-Namo edges, n=0 and n>length boundaries, uniq full-row dedupe plus numeric strictness plus block form, partition summing to the original, and subclass type preservation via Class.new(Namo). + Tests that select's filter and find_all aliases return Namos. + Guard tests that map/flat_map/reduce keep their original return types.
+7. ~ README.md: + Note in the Enumerable section that the subset-returning methods return Namos, with a chaining example and a first/last/uniq semantics paragraph. ~ Overview design-stance sentence to fold the Enumerable subset methods into "Namos in, Namos out".
+8. ~ ROADMAP.md: Promote 0.11.0 from upcoming to shipped under "Current state: 0.11.0"; fold the subset Enumerable methods into the Summary's completed vocabulary and point "next phase" at 0.12.0+; bump Date to 20260531.
+9. ~ Namo::VERSION: /0.10.0/0.11.0/
+
+20260528
+0.10.0: + Row value semantics: ==, eql?, hash
+
+1. + Namo::Row#==: Data equality. Two Rows are equal iff the other is a Row and their `@row` hashes are `==`. Class identity not gated (Row has no subclass hierarchy with included modules); formulae ignored (a formula is a property of the surrounding Namo, not of the row's identity). Mirrors `Namo#==` one level down.
+2. + Namo::Row#eql?: Strict data equality. Same shape as `==` but uses `Hash#eql?` on `@row`, matching Ruby's numeric-type-strict convention (`{n: 1}` Row is `eql?` to another `{n: 1}` Row, but not to a `{n: 1.0}` Row, just as `1.eql?(1.0)` is false).
+3. + Namo::Row#hash: Returns `@row.hash`. Consistent with `eql?` — Rows that are `eql?` produce equal hashes, so Rows participate correctly in Hash keys, Set members, and Array#uniq.
+4. ~ test/Namo/Row_test.rb: + `#==` tests (equal/different `@row`, non-Row operand, formulae ignored). + `#eql?` tests (equal `@row`, non-Row operand, `Hash#eql?` numeric-type strictness vs `==`, formulae ignored). + `#hash` tests (hash equality for `eql?` Rows, Rows as Hash keys, Rows as Set members deduplicating equal Rows).
+5. ~ README.md: + Note in the Equality section that Row participates in value semantics (`==`, `eql?`, `hash`) on the same data-only basis as `Namo#==`, ignoring formulae.
+6. ~ ROADMAP.md: Promote 0.10.0 from upcoming to shipped under "Current state: 0.10.0"; revise Summary to point "next phase" at 0.11.0+ and note Row value semantics among the algebra-completing pieces.
+7. ~ Namo::VERSION: /0.9.2/0.10.0/
+
 20260525
 0.9.2: ~ Auto-load Namo::VERSION
 

data/README.md

@@ -4,7 +4,7 @@ Named dimensional data for Ruby.
 
 Namo is a Ruby library for working with multi-dimensional data using named dimensions. It infers dimensions and coordinates from plain arrays of hashes — the same shape you get from databases, CSV files, JSON, and YAML — so there's no reshaping step.
 
-The design rests on a few stances: every hash key is a dimension and none is privileged as a coordinate or value; formulae attach to a Namo alongside data and re-evaluate on each access, appearing as derived dimensions alongside the data dimensions; operators that combine Namos all take Namos and return Namos, so analytical pipelines close; and the formula mechanism is type-agnostic — strings, dates, booleans, and arbitrary Ruby objects work as readily as numbers.
+The design rests on a few stances: every hash key is a dimension and none is privileged as a coordinate or value; formulae attach to a Namo alongside data and re-evaluate on each access, appearing as derived dimensions alongside the data dimensions; operators that combine Namos all take Namos and return Namos — as do the subset-returning Enumerable methods (`select`, `reject`, `sort_by`, `uniq`, and the rest) — so analytical pipelines close; and the formula mechanism is type-agnostic — strings, dates, booleans, and arbitrary Ruby objects work as readily as numbers.
 
 ## Installation
 
@@ -486,6 +486,18 @@ The two `:revenue` procs are independently-written and not the same object — `
 
 Each comparison operator answers a distinct question: `eql?` is strictest (class + data + formula names); `==` is data identity; `===` is analytical identity; the subset operators are data containment.
 
+Rows participate in value semantics on the same data-only basis. `Row#==`, `Row#eql?`, and `Row#hash` compare the underlying row hash and ignore the surrounding Namo's formulae — two Rows with the same data are equal regardless of which Namo yielded them. This makes Rows usable as Hash keys and Set members, and underwrites whole-row deduplication on the Enumerable side:
+
+```ruby
+a = Namo.new([{x: 1}]).first
+b = Namo.new([{x: 1}]).first
+a == b           # => true
+a.eql?(b)        # => true
+{a => :found}[b] # => :found
+```
+
+The omission of `Row#===` and Row-level `<`/`<=`/`>`/`>=` is deliberate: a Row is a record, not a collection, so the set-theoretic operators don't translate. The value-semantics trio (`==`, `eql?`, `hash`) is what a hash-shaped value needs to behave correctly in Ruby's collection machinery; that's the whole Row-comparison story.
+
 ### Subset and Superset
 
 `<`, `<=`, `>`, `>=` are multiset subset and superset relations on rows.
@@ -664,6 +676,20 @@ sales.flat_map{|row| [row[:price]]}
 # => [10.0, 10.0, 25.0, 25.0]
 ```
 
+The subset-returning Enumerable methods — `select`, `reject`, `sort_by`, `first(n)`, `last(n)`, `take`, `drop`, `take_while`, `drop_while`, `uniq`, and `partition` — return Namos rather than Arrays (`partition` returns `[Namo, Namo]`), carrying formulae through. This keeps the analytical chain closed: the result of a filter is still selectable, projectable, and operable, exactly like the operators that combine Namos:
+
+```ruby
+sales.select{|row| row[:price] < 20.0}.values(:price).sum
+# => 20.0
+
+sales.select{|row| row[:price] < 20.0}[product: 'Widget'][:quarter, :revenue].to_a
+# => [{quarter: 'Q1', revenue: 1000.0}, {quarter: 'Q2', revenue: 1500.0}]
+```
+
+Without an argument, `first` and `last` return a single `Row` (or `nil` on an empty Namo), following Ruby's convention; with an argument they return a Namo of that many rows. `uniq` dedupes on full-row equality (`Row#==`), or on a block's return value when given one. `select`'s aliases `filter` and `find_all` follow the override and return Namos too.
+
+The transforming and reducing methods are deliberately left as Enumerable's defaults, because their results aren't row-shaped and so can't be a Namo: `map`/`collect` and `flat_map` return Arrays of whatever the block produces; `reduce`/`inject`, `sum`, `count`, `min_by`, and `max_by` return scalars. `each` is unchanged — it yields Rows, or returns an Enumerator with no block.
+
 ### Extracting data
 
 `to_a` returns an array of hashes — the row-oriented form:

data/lib/Namo/Row.rb

@@ -11,6 +11,18 @@ class Namo
       end
     end
 
+    def ==(other)
+      other.is_a?(Row) && @row == other.to_h
+    end
+
+    def eql?(other)
+      other.is_a?(Row) && @row.eql?(other.to_h)
+    end
+
+    def hash
+      @row.hash
+    end
+
     def match?(selections)
       selections.all? do |dimension, coordinate|
         case coordinate

data/lib/Namo/VERSION.rb

@@ -2,5 +2,5 @@
 # Namo::VERSION
 
 class Namo
-  VERSION = '0.9.2'
+  VERSION = '0.11.0'
 end

data/lib/namo.rb

@@ -81,6 +81,65 @@ class Namo
     @data.each{|row_data| block.call(Row.new(row_data, @formulae))}
   end
 
+  def select(&block)
+    self.class.new(@data.select{|row| block.call(Row.new(row, @formulae))}, formulae: @formulae.dup)
+  end
+  alias_method :filter, :select
+  alias_method :find_all, :select
+
+  def reject(&block)
+    self.class.new(@data.reject{|row| block.call(Row.new(row, @formulae))}, formulae: @formulae.dup)
+  end
+
+  def sort_by(&block)
+    self.class.new(@data.sort_by{|row| block.call(Row.new(row, @formulae))}, formulae: @formulae.dup)
+  end
+
+  def first(n = nil)
+    if n
+      self.class.new(@data.first(n), formulae: @formulae.dup)
+    else
+      @data.first ? Row.new(@data.first, @formulae) : nil
+    end
+  end
+
+  def last(n = nil)
+    if n
+      self.class.new(@data.last(n), formulae: @formulae.dup)
+    else
+      @data.last ? Row.new(@data.last, @formulae) : nil
+    end
+  end
+
+  def take(n)
+    self.class.new(@data.take(n), formulae: @formulae.dup)
+  end
+
+  def drop(n)
+    self.class.new(@data.drop(n), formulae: @formulae.dup)
+  end
+
+  def take_while(&block)
+    self.class.new(@data.take_while{|row| block.call(Row.new(row, @formulae))}, formulae: @formulae.dup)
+  end
+
+  def drop_while(&block)
+    self.class.new(@data.drop_while{|row| block.call(Row.new(row, @formulae))}, formulae: @formulae.dup)
+  end
+
+  def uniq(&block)
+    rows = block ? @data.uniq{|row| block.call(Row.new(row, @formulae))} : @data.uniq
+    self.class.new(rows, formulae: @formulae.dup)
+  end
+
+  def partition(&block)
+    matches, non_matches = @data.partition{|row| block.call(Row.new(row, @formulae))}
+    [
+      self.class.new(matches, formulae: @formulae.dup),
+      self.class.new(non_matches, formulae: @formulae.dup),
+    ]
+  end
+
   def +(other)
     raise_unless_namo(other)
     raise_unless_matching_data_dimensions(other)

data/test/Namo/Row_test.rb

@@ -215,4 +215,81 @@ describe Namo::Row do
       _(row.to_h).must_equal row_data
     end
   end
+
+  describe "#==" do
+    it "is true for two Rows with equal @row" do
+      a = Namo::Row.new({product: 'Widget', price: 10.0}, {})
+      b = Namo::Row.new({product: 'Widget', price: 10.0}, {})
+      _(a == b).must_equal true
+    end
+
+    it "is false for two Rows with different @row" do
+      a = Namo::Row.new({product: 'Widget', price: 10.0}, {})
+      b = Namo::Row.new({product: 'Gadget', price: 10.0}, {})
+      _(a == b).must_equal false
+    end
+
+    it "is false for a non-Row operand" do
+      a = Namo::Row.new({product: 'Widget'}, {})
+      _(a == {product: 'Widget'}).must_equal false
+      _(a == 'Widget').must_equal false
+      _(a == nil).must_equal false
+    end
+
+    it "ignores formulae" do
+      a = Namo::Row.new({price: 10.0, quantity: 100}, {})
+      b = Namo::Row.new({price: 10.0, quantity: 100}, {revenue: proc{|r| r[:price] * r[:quantity]}})
+      _(a == b).must_equal true
+    end
+  end
+
+  describe "#eql?" do
+    it "is true for two Rows with eql? @row" do
+      a = Namo::Row.new({product: 'Widget', price: 10.0}, {})
+      b = Namo::Row.new({product: 'Widget', price: 10.0}, {})
+      _(a.eql?(b)).must_equal true
+    end
+
+    it "is false for a non-Row operand" do
+      a = Namo::Row.new({product: 'Widget'}, {})
+      _(a.eql?({product: 'Widget'})).must_equal false
+      _(a.eql?(nil)).must_equal false
+    end
+
+    it "distinguishes numeric types the way Hash#eql? does" do
+      a = Namo::Row.new({n: 1}, {})
+      b = Namo::Row.new({n: 1.0}, {})
+      _(a == b).must_equal true
+      _(a.eql?(b)).must_equal false
+    end
+
+    it "ignores formulae" do
+      a = Namo::Row.new({price: 10.0, quantity: 100}, {})
+      b = Namo::Row.new({price: 10.0, quantity: 100}, {revenue: proc{|r| r[:price] * r[:quantity]}})
+      _(a.eql?(b)).must_equal true
+    end
+  end
+
+  describe "#hash" do
+    it "is equal for two Rows that are eql?" do
+      a = Namo::Row.new({product: 'Widget', price: 10.0}, {})
+      b = Namo::Row.new({product: 'Widget', price: 10.0}, {})
+      _(a.hash).must_equal b.hash
+    end
+
+    it "lets Rows work as Hash keys" do
+      a = Namo::Row.new({product: 'Widget'}, {})
+      b = Namo::Row.new({product: 'Gadget'}, {})
+      lookup = Namo::Row.new({product: 'Widget'}, {})
+      h = {a => :x, b => :y}
+      _(h[lookup]).must_equal :x
+    end
+
+    it "lets Array#uniq dedupe equal Rows" do
+      a = Namo::Row.new({product: 'Widget'}, {})
+      b = Namo::Row.new({product: 'Gadget'}, {})
+      duplicate_of_a = Namo::Row.new({product: 'Widget'}, {})
+      _([a, b, duplicate_of_a].uniq.length).must_equal 2
+    end
+  end
 end

data/test/namo_test.rb

@@ -511,6 +511,408 @@ describe Namo do
     end
   end
 
+  describe "#select" do
+    it "returns a Namo of matching rows" do
+      result = sales.select{|row| row[:price] < 20.0}
+      _(result).must_be_kind_of Namo
+      _(result.to_a).must_equal [
+        {product: 'Widget', quarter: 'Q1', price: 10.0, quantity: 100},
+        {product: 'Widget', quarter: 'Q2', price: 10.0, quantity: 150}
+      ]
+    end
+
+    it "selects using formula references in the block" do
+      sales[:revenue] = proc{|r| r[:price] * r[:quantity]}
+      result = sales.select{|row| row[:revenue] >= 1500.0}
+      _(result.to_a).must_equal [
+        {product: 'Widget', quarter: 'Q2', price: 10.0, quantity: 150},
+        {product: 'Gadget', quarter: 'Q2', price: 25.0, quantity: 60}
+      ]
+    end
+
+    it "preserves formulae through to the returned Namo" do
+      sales[:revenue] = proc{|r| r[:price] * r[:quantity]}
+      result = sales.select{|row| row[:price] < 20.0}
+      _(result.values(:revenue)).must_equal [1000.0, 1500.0]
+    end
+
+    it "returns an empty Namo when nothing matches" do
+      result = sales.select{|row| row[:price] > 1000.0}
+      _(result).must_be_kind_of Namo
+      _(result.to_a).must_equal []
+    end
+
+    it "returns an instance of self's class" do
+      subclass = Class.new(Namo)
+      result = subclass.new(sample_data).select{|row| row[:price] < 20.0}
+      _(result.class).must_equal subclass
+    end
+
+    it "is aliased as filter, returning a Namo" do
+      result = sales.filter{|row| row[:price] < 20.0}
+      _(result).must_be_kind_of Namo
+      _(result.values(:product)).must_equal ['Widget', 'Widget']
+    end
+
+    it "is aliased as find_all, returning a Namo" do
+      result = sales.find_all{|row| row[:price] < 20.0}
+      _(result).must_be_kind_of Namo
+      _(result.values(:product)).must_equal ['Widget', 'Widget']
+    end
+  end
+
+  describe "#reject" do
+    it "returns the complement of select" do
+      result = sales.reject{|row| row[:price] < 20.0}
+      _(result).must_be_kind_of Namo
+      _(result.to_a).must_equal [
+        {product: 'Gadget', quarter: 'Q1', price: 25.0, quantity: 40},
+        {product: 'Gadget', quarter: 'Q2', price: 25.0, quantity: 60}
+      ]
+    end
+
+    it "together with select sums to the original" do
+      selected = sales.select{|row| row[:price] < 20.0}
+      rejected = sales.reject{|row| row[:price] < 20.0}
+      _((selected.to_a + rejected.to_a).length).must_equal sample_data.length
+    end
+
+    it "preserves formulae through to the returned Namo" do
+      sales[:revenue] = proc{|r| r[:price] * r[:quantity]}
+      result = sales.reject{|row| row[:price] < 20.0}
+      _(result.values(:revenue)).must_equal [1000.0, 1500.0]
+    end
+
+    it "returns an instance of self's class" do
+      subclass = Class.new(Namo)
+      result = subclass.new(sample_data).reject{|row| row[:price] < 20.0}
+      _(result.class).must_equal subclass
+    end
+  end
+
+  describe "#sort_by" do
+    it "returns rows in the specified order" do
+      result = sales.sort_by{|row| row[:quantity]}
+      _(result).must_be_kind_of Namo
+      _(result.values(:quantity)).must_equal [40, 60, 100, 150]
+    end
+
+    it "sorts using formula references in the block" do
+      sales[:revenue] = proc{|r| r[:price] * r[:quantity]}
+      result = sales.sort_by{|row| row[:revenue]}
+      _(result.values(:revenue)).must_equal [1000.0, 1000.0, 1500.0, 1500.0]
+    end
+
+    it "returns an instance of self's class" do
+      subclass = Class.new(Namo)
+      result = subclass.new(sample_data).sort_by{|row| row[:quantity]}
+      _(result.class).must_equal subclass
+    end
+  end
+
+  describe "#first" do
+    it "with an argument returns a Namo of the first n rows" do
+      result = sales.first(2)
+      _(result).must_be_kind_of Namo
+      _(result.to_a).must_equal [
+        {product: 'Widget', quarter: 'Q1', price: 10.0, quantity: 100},
+        {product: 'Widget', quarter: 'Q2', price: 10.0, quantity: 150}
+      ]
+    end
+
+    it "with an argument of 0 returns an empty Namo" do
+      result = sales.first(0)
+      _(result).must_be_kind_of Namo
+      _(result.to_a).must_equal []
+    end
+
+    it "without an argument returns a Row" do
+      result = sales.first
+      _(result).must_be_kind_of Namo::Row
+      _(result[:product]).must_equal 'Widget'
+    end
+
+    it "without an argument on an empty Namo returns nil" do
+      _(Namo.new.first).must_be_nil
+    end
+
+    it "preserves formulae through to the returned Namo" do
+      sales[:revenue] = proc{|r| r[:price] * r[:quantity]}
+      _(sales.first(2).values(:revenue)).must_equal [1000.0, 1500.0]
+    end
+
+    it "returns an instance of self's class with an argument" do
+      subclass = Class.new(Namo)
+      _(subclass.new(sample_data).first(2).class).must_equal subclass
+    end
+  end
+
+  describe "#last" do
+    it "with an argument returns a Namo of the last n rows" do
+      result = sales.last(2)
+      _(result).must_be_kind_of Namo
+      _(result.to_a).must_equal [
+        {product: 'Gadget', quarter: 'Q1', price: 25.0, quantity: 40},
+        {product: 'Gadget', quarter: 'Q2', price: 25.0, quantity: 60}
+      ]
+    end
+
+    it "with an argument of 0 returns an empty Namo" do
+      result = sales.last(0)
+      _(result).must_be_kind_of Namo
+      _(result.to_a).must_equal []
+    end
+
+    it "without an argument returns a Row" do
+      result = sales.last
+      _(result).must_be_kind_of Namo::Row
+      _(result[:product]).must_equal 'Gadget'
+      _(result[:quarter]).must_equal 'Q2'
+    end
+
+    it "without an argument on an empty Namo returns nil" do
+      _(Namo.new.last).must_be_nil
+    end
+
+    it "preserves formulae through to the returned Namo" do
+      sales[:revenue] = proc{|r| r[:price] * r[:quantity]}
+      _(sales.last(2).values(:revenue)).must_equal [1000.0, 1500.0]
+    end
+
+    it "returns an instance of self's class with an argument" do
+      subclass = Class.new(Namo)
+      _(subclass.new(sample_data).last(2).class).must_equal subclass
+    end
+  end
+
+  describe "#take" do
+    it "returns a Namo of the first n rows" do
+      result = sales.take(2)
+      _(result).must_be_kind_of Namo
+      _(result.values(:quantity)).must_equal [100, 150]
+    end
+
+    it "returns an empty Namo for n of 0" do
+      _(sales.take(0).to_a).must_equal []
+    end
+
+    it "returns all rows when n exceeds the length" do
+      _(sales.take(10).to_a).must_equal sample_data
+    end
+
+    it "returns an instance of self's class" do
+      subclass = Class.new(Namo)
+      _(subclass.new(sample_data).take(2).class).must_equal subclass
+    end
+  end
+
+  describe "#drop" do
+    it "returns a Namo of all rows past the first n" do
+      result = sales.drop(2)
+      _(result).must_be_kind_of Namo
+      _(result.values(:quantity)).must_equal [40, 60]
+    end
+
+    it "returns all rows for n of 0" do
+      _(sales.drop(0).to_a).must_equal sample_data
+    end
+
+    it "returns an empty Namo when n exceeds the length" do
+      _(sales.drop(10).to_a).must_equal []
+    end
+
+    it "returns an instance of self's class" do
+      subclass = Class.new(Namo)
+      _(subclass.new(sample_data).drop(2).class).must_equal subclass
+    end
+  end
+
+  describe "#take_while" do
+    it "returns a Namo of leading rows while the predicate holds" do
+      result = sales.take_while{|row| row[:price] < 20.0}
+      _(result).must_be_kind_of Namo
+      _(result.values(:product)).must_equal ['Widget', 'Widget']
+    end
+
+    it "evaluates the predicate against formula references" do
+      sales[:revenue] = proc{|r| r[:price] * r[:quantity]}
+      result = sales.take_while{|row| row[:revenue] < 1500.0}
+      _(result.values(:revenue)).must_equal [1000.0]
+    end
+
+    it "returns an instance of self's class" do
+      subclass = Class.new(Namo)
+      _(subclass.new(sample_data).take_while{|row| row[:price] < 20.0}.class).must_equal subclass
+    end
+  end
+
+  describe "#drop_while" do
+    it "returns a Namo of rows from the first predicate failure" do
+      result = sales.drop_while{|row| row[:price] < 20.0}
+      _(result).must_be_kind_of Namo
+      _(result.values(:product)).must_equal ['Gadget', 'Gadget']
+    end
+
+    it "evaluates the predicate against formula references" do
+      sales[:revenue] = proc{|r| r[:price] * r[:quantity]}
+      result = sales.drop_while{|row| row[:revenue] < 1500.0}
+      _(result.values(:revenue)).must_equal [1500.0, 1000.0, 1500.0]
+    end
+
+    it "returns an instance of self's class" do
+      subclass = Class.new(Namo)
+      _(subclass.new(sample_data).drop_while{|row| row[:price] < 20.0}.class).must_equal subclass
+    end
+  end
+
+  describe "#uniq" do
+    let(:dup_data) do
+      [
+        {product: 'Widget', quarter: 'Q1'},
+        {product: 'Widget', quarter: 'Q1'},
+        {product: 'Gadget', quarter: 'Q1'},
+        {product: 'Widget', quarter: 'Q2'}
+      ]
+    end
+
+    it "without a block dedupes rows on full-row equality" do
+      result = Namo.new(dup_data).uniq
+      _(result).must_be_kind_of Namo
+      _(result.to_a).must_equal [
+        {product: 'Widget', quarter: 'Q1'},
+        {product: 'Gadget', quarter: 'Q1'},
+        {product: 'Widget', quarter: 'Q2'}
+      ]
+    end
+
+    it "distinguishes numeric types, matching Row#eql? semantics" do
+      result = Namo.new([{n: 1}, {n: 1.0}]).uniq
+      _(result.to_a).must_equal [{n: 1}, {n: 1.0}]
+    end
+
+    it "with a block dedupes on the block's return value" do
+      result = Namo.new(dup_data).uniq{|row| row[:product]}
+      _(result.to_a).must_equal [
+        {product: 'Widget', quarter: 'Q1'},
+        {product: 'Gadget', quarter: 'Q1'}
+      ]
+    end
+
+    it "preserves formulae through to the returned Namo" do
+      namo = Namo.new(dup_data)
+      namo[:label] = proc{|r| "#{r[:product]}-#{r[:quarter]}"}
+      result = namo.uniq
+      _(result.values(:label)).must_equal ['Widget-Q1', 'Gadget-Q1', 'Widget-Q2']
+    end
+
+    it "returns an instance of self's class" do
+      subclass = Class.new(Namo)
+      _(subclass.new(dup_data).uniq.class).must_equal subclass
+    end
+  end
+
+  describe "#partition" do
+    it "returns a two-element Array of Namos" do
+      result = sales.partition{|row| row[:price] < 20.0}
+      _(result).must_be_kind_of Array
+      _(result.length).must_equal 2
+      _(result[0]).must_be_kind_of Namo
+      _(result[1]).must_be_kind_of Namo
+    end
+
+    it "splits into matches and non-matches summing to the original" do
+      matches, non_matches = sales.partition{|row| row[:price] < 20.0}
+      _(matches.to_a).must_equal [
+        {product: 'Widget', quarter: 'Q1', price: 10.0, quantity: 100},
+        {product: 'Widget', quarter: 'Q2', price: 10.0, quantity: 150}
+      ]
+      _(non_matches.to_a).must_equal [
+        {product: 'Gadget', quarter: 'Q1', price: 25.0, quantity: 40},
+        {product: 'Gadget', quarter: 'Q2', price: 25.0, quantity: 60}
+      ]
+      _((matches.to_a + non_matches.to_a).length).must_equal sample_data.length
+    end
+
+    it "partitions using formula references in the block" do
+      sales[:revenue] = proc{|r| r[:price] * r[:quantity]}
+      matches, non_matches = sales.partition{|row| row[:revenue] >= 1500.0}
+      _(matches.values(:revenue)).must_equal [1500.0, 1500.0]
+      _(non_matches.values(:revenue)).must_equal [1000.0, 1000.0]
+    end
+
+    it "preserves formulae through to both returned Namos" do
+      sales[:revenue] = proc{|r| r[:price] * r[:quantity]}
+      matches, non_matches = sales.partition{|row| row[:price] < 20.0}
+      _(matches.values(:revenue)).must_equal [1000.0, 1500.0]
+      _(non_matches.values(:revenue)).must_equal [1000.0, 1500.0]
+    end
+
+    it "returns instances of self's class" do
+      subclass = Class.new(Namo)
+      matches, non_matches = subclass.new(sample_data).partition{|row| row[:price] < 20.0}
+      _(matches.class).must_equal subclass
+      _(non_matches.class).must_equal subclass
+    end
+  end
+
+  describe "subset methods on an empty Namo" do
+    let(:empty) { Namo.new }
+
+    it "select returns an empty Namo" do
+      _(empty.select{|row| true}.to_a).must_equal []
+    end
+
+    it "reject returns an empty Namo" do
+      _(empty.reject{|row| true}.to_a).must_equal []
+    end
+
+    it "sort_by returns an empty Namo" do
+      _(empty.sort_by{|row| row[:x]}.to_a).must_equal []
+    end
+
+    it "first(n) returns an empty Namo" do
+      _(empty.first(2).to_a).must_equal []
+    end
+
+    it "last(n) returns an empty Namo" do
+      _(empty.last(2).to_a).must_equal []
+    end
+
+    it "take and drop return empty Namos" do
+      _(empty.take(2).to_a).must_equal []
+      _(empty.drop(2).to_a).must_equal []
+    end
+
+    it "take_while and drop_while return empty Namos" do
+      _(empty.take_while{|row| true}.to_a).must_equal []
+      _(empty.drop_while{|row| true}.to_a).must_equal []
+    end
+
+    it "uniq returns an empty Namo" do
+      _(empty.uniq.to_a).must_equal []
+    end
+
+    it "partition returns two empty Namos" do
+      matches, non_matches = empty.partition{|row| true}
+      _(matches.to_a).must_equal []
+      _(non_matches.to_a).must_equal []
+    end
+  end
+
+  describe "unchanged Enumerable methods" do
+    it "map still returns an Array" do
+      _(sales.map{|row| row[:product]}).must_be_kind_of Array
+    end
+
+    it "flat_map still returns an Array" do
+      _(sales.flat_map{|row| [row[:price]]}).must_be_kind_of Array
+    end
+
+    it "reduce still returns a scalar" do
+      _(sales.reduce(0){|sum, row| sum + row[:quantity]}).must_equal 350
+    end
+  end
+
   describe "#+" do
     let(:more_data) do
       [

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: namo
 version: !ruby/object:Gem::Version
-  version: 0.9.2
+  version: 0.11.0
 platform: ruby
 authors:
 - thoran