namo 0.7.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c0aa48a727f9cc67fae8eea94dcfa8227c66a34aa8918ac65e30b33b7685c82b
-  data.tar.gz: c8f634b5c41f35337fb843d286edf80cbdabef951b076dd36533f5a2531c3715
+  metadata.gz: 7adbe8192367d3c4207f7b27ff0b6a8a13f5243b42a4e4f18a6fbc35ef6439be
+  data.tar.gz: cda1e8b3d8fc042b4457efc0bc7846d5a416a5eda670d140824a4f8ad193a0f2
 SHA512:
-  metadata.gz: 9b196446a0d02dc61790a25ea416bfebdd591020cfd6ef89430f5e8b9d8bd1239cc265bca83f0cd6dde4d42ce3c3927074ac69e1d4e79ae88db667b95caeadf3
-  data.tar.gz: 3680f44daa8e1e78921d1d286c7f436947b6e436c9308d62038c17a1f9658ae4ccc23196afb2eb44e6b3efb41398ab1b39d8cf3bf813f87c24df12c7cb975586
+  metadata.gz: 60d639f243fc7bf306576b69ac646be388571b343330e5636f7c862519169cbaca3a36beb1cfccf16462b7e65b4735ca1b38e948db693c094c3636507531ebd4
+  data.tar.gz: 5898c9f8b7d9196481a964826cee97a8f1a962916f818604fa4ea647c1b59d5b05e17ea0ac5a578c6cd2a7d499100d95a10344029e7b6abd5bce70a41efc9b1f

data/CHANGELOG

@@ -1,6 +1,31 @@
 CHANGELOG
 _________
 
+20260521
+0.9.0: + composition operators: equi-join (*), Cartesian product (**), decomposition (/)
+
+1. + Namo#*: Equi-join on shared data dimensions. Inner-join semantics — unmatched rows from both sides are dropped. Raises ArgumentError ("no shared dimensions, need to have shared dimensions") when operands have no overlap. Preserves duplicates multiplicatively. Formulae merge with self winning on conflict.
+2. + Namo#**: Cartesian product of two Namos with disjoint data dimensions. Raises ArgumentError ("dimensions in common, need no common dimensions") when any dimension is shared. Output has left.length * right.length rows. Formulae merge with self winning on conflict.
+3. + Namo#/: Decomposition. Removes from self the dimensions that are also in other (the intersection), then dedupes the projected rows. No precondition — total on Namo × Namo. When self and other share no dimensions, the operator is a no-op. Formulae carry through from self. (a ** b) / b == a exactly; (a * b) / b loses dimensions shared between a and b.
+4. + Namo#raise_unless_shared_data_dimensions, Namo#raise_unless_disjoint_data_dimensions: Private precondition helpers for #* and #** respectively.
+5. ~ test/namo_test.rb: + #* tests (single/multi-dimension join, inner-join symmetry, multiplicative duplicates, formulae merging, error cases). + #** tests (Cartesian product, output sizing, dimension overlap error). + #/ tests (intersection removal, dedupe of collided rows, no-op on disjoint operands, idempotence). + Composition round-trip tests for the ** case (exact identity) and the * case (lossy on shared dimensions).
+6. ~ README.md: + Composition section (*), + Cartesian product section (**), + Decomposition section (/) including the combining-vs-projecting rationale for /'s no-precondition design. Placed after Symmetric Difference and before Equality.
+7. ~ ROADMAP.md: Promote 0.9.0 from upcoming to shipped under "Current state: 0.9.0"; revise Summary to include composition in the operator vocabulary and point "next phase" at 0.10.0+.
+8. ~ COMPARISON.md: /planned (0.9.0)/shipped (0.9.0)/ for Equi-join, Cartesian product, and Decomposition. + Paragraph in the Decomposition entry on the combining-vs-projecting distinction. Date bumped to 20260521.
+9. ~ Namo::VERSION: /0.8.0/0.9.0/
+
+20260521
+0.8.0: + proc and regex-based selection
+
+1. ~ Namo::Row#match?: + `when Proc` branch — calls the proc with the dimension value; truthy result selects the row. Predicate receives nil for missing or nil-valued dimensions and decides.
+2. ~ Namo::Row#match?: + `when Regexp` branch — matches against row[dimension].to_s. nil becomes "" (matches //, not /./); Integer/Float/Date/Symbol coerce via to_s.
+3. ~ test/Namo/Row_test.rb: + Proc-predicate tests (true/false/nil/truthy non-boolean returns, nil dimension values, composition with exact/array/range/regex, multiple proc predicates across dimensions, carry-through to formula-defined dimensions). + Regexp-predicate tests (match/no-match/case-insensitive on Strings, to_s coercion of Integer/Float/Date/Symbol/nil, composition with exact/array/range/proc, multiple regex predicates across dimensions, carry-through to formula-defined dimensions).
+4. ~ test/namo_test.rb: + End-to-end tests for proc selection, regex selection, and mixed proc/regex selection, including composition with projection and contraction in a single call and selection on formula-defined dimensions.
+5. ~ README.md: + Proc and regex examples in the Selection section; + paragraphs on proc semantics (truthy/nil-aware, composes with everything) and regex semantics (.to_s coercion across nil/String/Symbol/Integer/Float/Date).
+6. ~ ROADMAP.md: Promote 0.8.0 from upcoming to shipped under "Current state: 0.8.0"; revise Summary to include proc/regex in the selection vocabulary and point "next phase" at 0.9.0+.
+7. ~ CHANGELOG: Update with 0.8.0's changes and retroactively log the 0.7.0 changes to README (+ Coordinates and values section), COMPARISON.md, and EXAMPLES.md (2 sections relocated from EXAMPLES.md to COMPARISON.md).
+8. ~ Namo::VERSION: /0.7.0/0.8.0/
+
 20260520
 0.7.0: + derived-dimension surfacing, lazy single-column access, live views
 
@@ -14,8 +39,12 @@ _________
 8. ~ Namo#canonical_data: Sorts by data_dimensions to preserve 0.6.0 row-equality semantics under the broader dimensions definition.
 9. /raise_unless_matching_dimensions/raise_unless_matching_data_dimensions/: Private helper renamed to reflect what it actually compares.
 10. ~ test/namo_test.rb: + Tests for #data_dimensions, #derived_dimensions, the no-arg/single-arg/multi-arg forms of #values and #coordinates, derived-dimension surfacing in #dimensions, #to_h, the coordinates(dim) == values(dim).uniq consistency property, and live-view semantics (added rows / formulae reflected on next call).
-11. ~ Rakefile: + -V mainfont=Charter -V monofont=Menlo on pandoc invocation in docs:md2pdf, for a cleaner serif body font and so code spans containing Unicode math glyphs (e.g. ∅) render correctly under xelatex.
-12. ~ Namo::VERSION: /0.6.0/0.7.0/
+11. ~ README.md: + Coordinates and values section covering #values, #coordinates(*dims), #data_dimensions, #derived_dimensions, and #to_h.
+12. ~ COMPARISON.md: + "Worked example: comparing yesterday's screen to today's" under the set-operators section; + "Schema dispatch on incoming data feeds" under the equality/=== section. Date bumped to 20260520.
+13. ~ EXAMPLES.md: - "Schema dispatch on incoming data feeds", - "Comparing yesterday's screen to today's" — both relocated to COMPARISON.md as worked examples under the matching feature sections. Date bumped to 20260520.
+14. ~ ROADMAP.md: Promote 0.7.0 from upcoming to shipped under "Current state: 0.7.0"; point "next phase" at 0.8.0+.
+15. ~ Rakefile: + -V mainfont=Charter -V monofont=Menlo on pandoc invocation in docs:md2pdf, for a cleaner serif body font and so code spans containing Unicode math glyphs (e.g. ∅) render correctly under xelatex.
+16. ~ Namo::VERSION: /0.6.0/0.7.0/
 
 20260511
 0.6.0: + equality, pattern-match, and subset/superset operators

data/README.md

@@ -79,8 +79,41 @@ sales[quarter: ['Q1']]
 #   {product: 'Widget', quarter: 'Q1', price: 10.0, quantity: 100},
 #   {product: 'Gadget', quarter: 'Q1', price: 25.0, quantity: 40}
 # ]>
+
+# Proc predicate
+sales[price: ->(v){v < 20.0}]
+# => #<Namo [
+#   {product: 'Widget', quarter: 'Q1', price: 10.0, quantity: 100},
+#   {product: 'Widget', quarter: 'Q2', price: 10.0, quantity: 150}
+# ]>
+
+# Regex predicate
+sales[product: /^W/]
+# => #<Namo [
+#   {product: 'Widget', quarter: 'Q1', price: 10.0, quantity: 100},
+#   {product: 'Widget', quarter: 'Q2', price: 10.0, quantity: 150}
+# ]>
+```
+
+Procs receive the dimension value and select the row when they return truthy. They handle arbitrary predicates — multi-condition tests, nil-aware checks, anything Ruby can express — and compose with everything else:
+
+```ruby
+sales[price: ->(v){v < 20.0}, quantity: ->(v){v > 100}]
+# => #<Namo [
+#   {product: 'Widget', quarter: 'Q2', price: 10.0, quantity: 150}
+# ]>
+```
+
+Regexes match against the dimension value coerced with `to_s`, so they work against strings, symbols, numbers, dates, or anything else with a sensible string form. `nil` becomes `""` — `//` matches it, `/./` doesn't.
+
+```ruby
+sales[product: /widget/i]                          # case-insensitive
+sales[product: /Widget|Gadget/]                    # alternation
+sales[product: /^W/, quarter: 'Q1']                # mixed with exact
 ```
 
+Procs and regexes mix freely with exact values, arrays, ranges, projection, and contraction in the same `[]` call.
+
 ### Projection
 
 Project to specific dimensions:
@@ -286,6 +319,124 @@ set_a ^ set_b
 
 The dimensions must match; different dimensions raise an `ArgumentError`. Formulae merge from both sides; the left-hand side's formulae take precedence on conflict.
 
+### Composition
+
+`*` is the equi-join operator. It pairs rows from two Namos where coordinates match on every shared dimension, like an inner join on the shared dimension names:
+
+```ruby
+ohlcv = Namo.new([
+  {symbol: 'BHP', date: '2025-01-01', close: 42.5},
+  {symbol: 'RIO', date: '2025-01-01', close: 118.3}
+])
+
+fundamentals = Namo.new([
+  {symbol: 'BHP', pe: 14.5},
+  {symbol: 'RIO', pe: 9.2}
+])
+
+ohlcv * fundamentals
+# => #<Namo [
+#   {symbol: 'BHP', date: '2025-01-01', close: 42.5, pe: 14.5},
+#   {symbol: 'RIO', date: '2025-01-01', close: 118.3, pe: 9.2}
+# ]>
+```
+
+Inner-join semantics: unmatched rows from either side are dropped. Output dimensions are `self.data_dimensions` followed by `other.data_dimensions` exclusive to other. Duplicates on shared coordinates are preserved multiplicatively — output multiplicity is the product of input multiplicities on each matching key.
+
+The two Namos must have at least one shared data dimension. No overlap raises an `ArgumentError` — the asymmetry with `**` is deliberate, and falling through to a Cartesian product would silently turn a logic error into a large pile of nonsense rows. Formulae merge from both sides; the left-hand side wins on conflict.
+
+### Cartesian product
+
+`**` is the Cartesian product. Every row from the left paired with every row from the right:
+
+```ruby
+products = Namo.new([{product: 'Widget'}, {product: 'Gadget'}])
+quarters = Namo.new([{quarter: 'Q1'}, {quarter: 'Q2'}])
+
+products ** quarters
+# => #<Namo [
+#   {product: 'Widget', quarter: 'Q1'},
+#   {product: 'Widget', quarter: 'Q2'},
+#   {product: 'Gadget', quarter: 'Q1'},
+#   {product: 'Gadget', quarter: 'Q2'}
+# ]>
+```
+
+Output has `self.data.length * other.data.length` rows. Output dimensions are `self.data_dimensions + other.data_dimensions`, in operand order. Duplicates are preserved multiplicatively.
+
+The two Namos must have **no** shared data dimensions — the precondition is the mirror image of `*`. Any overlap raises an `ArgumentError`; allowing it would produce rows with the same dimension named twice. Formulae merge from both sides; the left-hand side wins on conflict.
+
+The visual relationship is intentional: `*` is the filtered version, `**` is the explosive version — more sigil, more output.
+
+### Decomposition
+
+`/` removes from the left Namo the dimensions that are also in the right, then dedupes the projected rows. It's the inverse of `*` and `**`:
+
+```ruby
+combined = Namo.new([
+  {symbol: 'BHP', date: '2025-01-01', close: 42.5, pe: 14.5},
+  {symbol: 'RIO', date: '2025-01-01', close: 118.3, pe: 9.2}
+])
+
+fundamentals = Namo.new([
+  {symbol: 'BHP', pe: 14.5},
+  {symbol: 'RIO', pe: 9.2}
+])
+
+combined / fundamentals
+# => #<Namo [
+#   {date: '2025-01-01', close: 42.5},
+#   {date: '2025-01-01', close: 118.3}
+# ]>
+```
+
+The intersection of dimensions — here `:symbol` and `:pe` — is removed. Everything else stays. The projected rows are deduplicated, so `/` answers "what's left when these dimensions are factored out?" rather than "what rows survive a column drop?". Formulae carry through from the left-hand side.
+
+`/` has no precondition. When the two Namos share no dimensions, the intersection is empty, nothing is removed, and `self / other` returns a Namo equal to self:
+
+```ruby
+shipments = Namo.new([{order_id: 1, weight: 10}])
+weather = Namo.new([{date: '2025-01-01', temperature: 22}])
+
+shipments / weather
+# => #<Namo [{order_id: 1, weight: 10}]> — equal to shipments
+```
+
+The round-trip identity holds for the `**` case exactly:
+
+```ruby
+a = Namo.new([{symbol: 'BHP'}, {symbol: 'RIO'}])
+b = Namo.new([{quarter: 'Q1'}, {quarter: 'Q2'}])
+
+(a ** b) / b == a
+# => true
+```
+
+For `*`, the round-trip is lossy on the dimensions that were shared between the operands:
+
+```ruby
+a = Namo.new([{symbol: 'BHP', close: 42.5}, {symbol: 'RIO', close: 118.3}])
+b = Namo.new([{symbol: 'BHP', pe: 14.5}, {symbol: 'RIO', pe: 9.2}])
+
+(a * b) / b
+# => #<Namo [{close: 42.5}, {close: 118.3}]>
+# Equal to a[-:symbol]. :symbol was shared and is lost.
+```
+
+The asymmetry is inherent: `/` operates only on the two values it receives and can't distinguish "shared dimension that belonged to both" from "exclusive dimension that belonged only to the right". Removing the intersection is the only rule expressible from the operands alone, and it gives clean recovery from `**` and well-defined (if lossy) recovery from `*`.
+
+#### Why `/` is loose
+
+`*` and `**` raise when their preconditions are violated — combining unrelated Namos has no natural answer, and silently producing arbitrary output would turn a logic error into a large pile of nonsense rows. `/` is different: it's a projecting operator, not a combining one, and projecting away nothing returns the original. The no-precondition rule isn't a fallback; it's the structurally correct result.
+
+This earns `/` three properties a strict version would lose:
+
+- **Identity test.** `combined / other == combined` exactly when the two have no shared dimensions — answers "are these Namos dimensionally independent?" without explicit introspection. Same shape as `a & b == a` answering subset from 0.6.0.
+- **Idempotence.** `(c / b) / b == c / b`. Once `b`'s dimensions are removed, removing them again does nothing.
+- **Pipeline composition.** A processing step that applies `/ separator` can run over any Namo regardless of whether the separator's dimensions apply. Uninvolved Namos pass through unchanged; involved Namos get stripped. The pipeline doesn't need to special-case applicability.
+
+This is the same pattern that makes `Array#-` useful with arrays that aren't subsets: `[1, 2, 3] - [9] == [1, 2, 3]`, not an error. The no-op-on-non-applicable behaviour lets the operator compose into pipelines that don't know in advance whether the operation applies.
+
 ### Equality
 
 Comparison on Namos is **multiset-theoretic on rows**: row order is ignored (it's an accident of ingestion, not data), but row multiplicities count (they *are* data). The same stance carries across the equality, pattern-match, and subset/superset operators below.

data/lib/Namo/Row.rb

@@ -16,6 +16,10 @@ class Namo
         case coordinate
         when Array, Range
           coordinate.include?(self[dimension])
+        when Proc
+          coordinate.call(self[dimension])
+        when Regexp
+          coordinate.match?(self[dimension].to_s)
         else
           self[dimension] == coordinate
         end

data/lib/Namo/VERSION.rb

@@ -2,5 +2,5 @@
 # Namo::VERSION
 
 class Namo
-  VERSION = '0.7.0'
+  VERSION = '0.9.0'
 end

data/lib/namo.rb

@@ -110,6 +110,42 @@ class Namo
     self.class.new((@data - other.data) + (other.data - @data), formulae: other.formulae.merge(@formulae))
   end
 
+  def *(other)
+    raise_unless_namo(other)
+    raise_unless_shared_data_dimensions(other)
+    shared = data_dimensions & other.data_dimensions
+    combined_data = []
+    @data.each do |left_row|
+      other.data.each do |right_row|
+        if shared.all?{|dim| left_row[dim] == right_row[dim]}
+          combined_data << left_row.merge(right_row)
+        end
+      end
+    end
+    self.class.new(combined_data, formulae: other.formulae.merge(@formulae))
+  end
+
+  def **(other)
+    raise_unless_namo(other)
+    raise_unless_disjoint_data_dimensions(other)
+    combined_data = []
+    @data.each do |left_row|
+      other.data.each do |right_row|
+        combined_data << left_row.merge(right_row)
+      end
+    end
+    self.class.new(combined_data, formulae: other.formulae.merge(@formulae))
+  end
+
+  def /(other)
+    raise_unless_namo(other)
+    kept = data_dimensions - other.data_dimensions
+    projected = @data.map do |row|
+      kept.each_with_object({}){|dim, hash| hash[dim] = row[dim]}
+    end
+    self.class.new(projected.uniq, formulae: @formulae.dup)
+  end
+
   def ==(other)
     return false unless other.is_a?(Namo)
     canonical_data == other.canonical_data
@@ -201,6 +237,18 @@ class Namo
     end
   end
 
+  def raise_unless_shared_data_dimensions(other)
+    if (data_dimensions & other.data_dimensions).empty?
+      raise ArgumentError, "no shared dimensions, need to have shared dimensions: #{data_dimensions} vs #{other.data_dimensions}"
+    end
+  end
+
+  def raise_unless_disjoint_data_dimensions(other)
+    if (data_dimensions & other.data_dimensions).any?
+      raise ArgumentError, "dimensions in common, need no common dimensions: #{data_dimensions} vs #{other.data_dimensions}"
+    end
+  end
+
   def initialize(data = nil, formulae: {})
     @data = data
     @formulae = formulae

data/test/Namo/Row_test.rb

@@ -1,3 +1,4 @@
+require 'date'
 require 'minitest/autorun'
 require 'minitest-spec-context'
 
@@ -59,6 +60,154 @@ describe Namo::Row do
       _(row.match?(product: 'Widget', quarter: 'Q1')).must_equal true
       _(row.match?(product: 'Widget', quarter: 'Q2')).must_equal false
     end
+
+    describe "Proc predicates" do
+      it "matches when the proc returns true" do
+        _(row.match?(price: ->(v){v < 15.0})).must_equal true
+      end
+
+      it "doesn't match when the proc returns false" do
+        _(row.match?(price: ->(v){v > 100.0})).must_equal false
+      end
+
+      it "doesn't match when the proc returns nil" do
+        _(row.match?(price: ->(v){nil})).must_equal false
+      end
+
+      it "matches when the proc returns a truthy non-boolean" do
+        _(row.match?(price: ->(v){"truthy"})).must_equal true
+      end
+
+      it "passes nil to the proc when the dimension is missing" do
+        seen = nil
+        row.match?(missing: ->(v){seen = v; true})
+        _(seen).must_be_nil
+      end
+
+      it "lets the proc decide what to do with a nil value" do
+        _(row.match?(missing: ->(v){v.nil?})).must_equal true
+        _(row.match?(missing: ->(v){!v.nil?})).must_equal false
+      end
+
+      it "composes with an exact value on another dimension" do
+        _(row.match?(price: ->(v){v < 15.0}, product: 'Widget')).must_equal true
+        _(row.match?(price: ->(v){v < 15.0}, product: 'Gadget')).must_equal false
+      end
+
+      it "composes with an array on another dimension" do
+        _(row.match?(price: ->(v){v < 15.0}, product: ['Widget', 'Gadget'])).must_equal true
+        _(row.match?(price: ->(v){v < 15.0}, product: ['Gadget'])).must_equal false
+      end
+
+      it "composes with a range on another dimension" do
+        _(row.match?(price: ->(v){v < 15.0}, quantity: 50..150)).must_equal true
+        _(row.match?(price: ->(v){v < 15.0}, quantity: 200..300)).must_equal false
+      end
+
+      it "composes with a regex on another dimension" do
+        _(row.match?(price: ->(v){v < 15.0}, product: /^W/)).must_equal true
+        _(row.match?(price: ->(v){v < 15.0}, product: /^G/)).must_equal false
+      end
+
+      it "composes multiple proc predicates across dimensions" do
+        _(row.match?(
+          price: ->(v){v < 15.0},
+          quantity: ->(v){v >= 100}
+        )).must_equal true
+        _(row.match?(
+          price: ->(v){v < 15.0},
+          quantity: ->(v){v >= 200}
+        )).must_equal false
+      end
+
+      it "carries through to a formula-defined dimension" do
+        formulae[:revenue] = proc{|r| r[:price] * r[:quantity]}
+        _(row.match?(revenue: ->(v){v == 1000.0})).must_equal true
+        _(row.match?(revenue: ->(v){v > 5000.0})).must_equal false
+      end
+    end
+
+    describe "Regexp predicates" do
+      it "matches against a String value" do
+        _(row.match?(product: /Widget/)).must_equal true
+      end
+
+      it "doesn't match when the regex doesn't apply" do
+        _(row.match?(product: /Gadget/)).must_equal false
+      end
+
+      it "supports case-insensitive matching" do
+        _(row.match?(product: /widget/i)).must_equal true
+        _(row.match?(product: /widget/)).must_equal false
+      end
+
+      it "supports anchored patterns" do
+        _(row.match?(product: /^Wid/)).must_equal true
+        _(row.match?(product: /^Gad/)).must_equal false
+      end
+
+      it "coerces Integer values via to_s" do
+        _(row.match?(quantity: /100/)).must_equal true
+        _(row.match?(quantity: /^1/)).must_equal true
+        _(row.match?(quantity: /^9/)).must_equal false
+      end
+
+      it "coerces Float values via to_s" do
+        _(row.match?(price: /^10\./)).must_equal true
+        _(row.match?(price: /\.0$/)).must_equal true
+        _(row.match?(price: /^99/)).must_equal false
+      end
+
+      it "coerces Date values via to_s" do
+        row_data[:date] = Date.new(2026, 5, 21)
+        _(row.match?(date: /^2026/)).must_equal true
+        _(row.match?(date: /-05-/)).must_equal true
+        _(row.match?(date: /^2025/)).must_equal false
+      end
+
+      it "coerces Symbol values via to_s" do
+        row_data[:tag] = :priority
+        _(row.match?(tag: /priority/)).must_equal true
+        _(row.match?(tag: /^pri/)).must_equal true
+        _(row.match?(tag: /xyz/)).must_equal false
+      end
+
+      it "coerces nil to an empty string" do
+        _(row.match?(missing: //)).must_equal true
+        _(row.match?(missing: /./)).must_equal false
+      end
+
+      it "composes with an exact value on another dimension" do
+        _(row.match?(product: /^W/, quarter: 'Q1')).must_equal true
+        _(row.match?(product: /^W/, quarter: 'Q2')).must_equal false
+      end
+
+      it "composes with an array on another dimension" do
+        _(row.match?(product: /^W/, quarter: ['Q1', 'Q2'])).must_equal true
+        _(row.match?(product: /^W/, quarter: ['Q3'])).must_equal false
+      end
+
+      it "composes with a range on another dimension" do
+        _(row.match?(product: /^W/, price: 5.0..15.0)).must_equal true
+        _(row.match?(product: /^W/, price: 20.0..30.0)).must_equal false
+      end
+
+      it "composes with a proc on another dimension" do
+        _(row.match?(product: /^W/, quantity: ->(v){v >= 100})).must_equal true
+        _(row.match?(product: /^W/, quantity: ->(v){v >= 200})).must_equal false
+      end
+
+      it "composes multiple regex predicates across dimensions" do
+        _(row.match?(product: /^W/, quarter: /^Q/)).must_equal true
+        _(row.match?(product: /^W/, quarter: /^X/)).must_equal false
+      end
+
+      it "carries through to a formula-defined dimension" do
+        formulae[:label] = proc{|r| "#{r[:product]}-#{r[:quarter]}"}
+        _(row.match?(label: /Widget-Q1/)).must_equal true
+        _(row.match?(label: /Gadget/)).must_equal false
+      end
+    end
   end
 
   describe "#to_h" do

data/test/namo_test.rb

@@ -272,6 +272,110 @@ describe Namo do
         ]
       end
     end
+
+    context "proc selection" do
+      it "selects rows where the proc returns truthy" do
+        result = sales[price: ->(v){v < 15.0}]
+        _(result.to_a.count).must_equal 2
+        _(result.to_a.map{|row| row[:product]}).must_equal ['Widget', 'Widget']
+      end
+
+      it "selects on multiple proc dimensions" do
+        result = sales[price: ->(v){v < 30.0}, quantity: ->(v){v > 50}]
+        _(result.to_a).must_equal [
+          {product: 'Widget', quarter: 'Q1', price: 10.0, quantity: 100},
+          {product: 'Widget', quarter: 'Q2', price: 10.0, quantity: 150},
+          {product: 'Gadget', quarter: 'Q2', price: 25.0, quantity: 60}
+        ]
+      end
+
+      it "composes with projection in a single call" do
+        result = sales[:product, :price, price: ->(v){v < 15.0}]
+        _(result.to_a).must_equal [
+          {product: 'Widget', price: 10.0},
+          {product: 'Widget', price: 10.0}
+        ]
+      end
+
+      it "composes with contraction in a single call" do
+        result = sales[-:quantity, price: ->(v){v < 15.0}]
+        _(result.to_a).must_equal [
+          {product: 'Widget', quarter: 'Q1', price: 10.0},
+          {product: 'Widget', quarter: 'Q2', price: 10.0}
+        ]
+      end
+
+      it "selects on a formula-defined dimension" do
+        sales[:revenue] = proc{|r| r[:price] * r[:quantity]}
+        result = sales[revenue: ->(v){v >= 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
+    end
+
+    context "regex selection" do
+      it "selects by regex against String values" do
+        result = sales[product: /^W/]
+        _(result.to_a.count).must_equal 2
+        _(result.to_a.map{|row| row[:product]}).must_equal ['Widget', 'Widget']
+      end
+
+      it "supports case-insensitive matching" do
+        result = sales[product: /widget/i]
+        _(result.to_a.count).must_equal 2
+      end
+
+      it "supports alternation" do
+        result = sales[product: /Widget|Gadget/]
+        _(result.to_a.count).must_equal 4
+      end
+
+      it "coerces non-String values via to_s" do
+        result = sales[quantity: /^1/]
+        _(result.to_a.map{|row| row[:quantity]}).must_equal [100, 150]
+      end
+
+      it "composes with an exact value on another dimension" do
+        result = sales[product: /^W/, quarter: 'Q1']
+        _(result.to_a).must_equal [
+          {product: 'Widget', quarter: 'Q1', price: 10.0, quantity: 100}
+        ]
+      end
+
+      it "composes with projection in a single call" do
+        result = sales[:product, :quarter, product: /^W/]
+        _(result.to_a).must_equal [
+          {product: 'Widget', quarter: 'Q1'},
+          {product: 'Widget', quarter: 'Q2'}
+        ]
+      end
+
+      it "composes with contraction in a single call" do
+        result = sales[-:price, -:quantity, product: /^W/]
+        _(result.to_a).must_equal [
+          {product: 'Widget', quarter: 'Q1'},
+          {product: 'Widget', quarter: 'Q2'}
+        ]
+      end
+
+      it "selects on a formula-defined dimension" do
+        sales[:label] = proc{|r| "#{r[:product]}-#{r[:quarter]}"}
+        result = sales[label: /Widget/]
+        _(result.to_a.count).must_equal 2
+        _(result.map{|row| row[:label]}).must_equal ['Widget-Q1', 'Widget-Q2']
+      end
+    end
+
+    context "mixed proc and regex selection" do
+      it "combines a proc and a regex across dimensions" do
+        result = sales[product: /^W/, quantity: ->(v){v > 100}]
+        _(result.to_a).must_equal [
+          {product: 'Widget', quarter: 'Q2', price: 10.0, quantity: 150}
+        ]
+      end
+    end
   end
 
   describe "#[]= formulae" do
@@ -606,6 +710,288 @@ describe Namo do
     end
   end
 
+  describe "#*" do
+    let(:ohlcv) do
+      Namo.new([
+        {symbol: 'BHP', date: '2025-01-01', close: 42.5},
+        {symbol: 'RIO', date: '2025-01-01', close: 118.3}
+      ])
+    end
+
+    let(:fundamentals) do
+      Namo.new([
+        {symbol: 'BHP', pe: 14.5},
+        {symbol: 'RIO', pe: 9.2}
+      ])
+    end
+
+    it "joins on a single shared dimension" do
+      result = ohlcv * fundamentals
+      _(result.to_a).must_equal [
+        {symbol: 'BHP', date: '2025-01-01', close: 42.5, pe: 14.5},
+        {symbol: 'RIO', date: '2025-01-01', close: 118.3, pe: 9.2}
+      ]
+    end
+
+    it "joins on multiple shared dimensions" do
+      a = Namo.new([
+        {symbol: 'BHP', date: '2025-01-01', close: 42.5},
+        {symbol: 'BHP', date: '2025-01-02', close: 43.0}
+      ])
+      b = Namo.new([
+        {symbol: 'BHP', date: '2025-01-01', volume: 1000},
+        {symbol: 'BHP', date: '2025-01-02', volume: 1500}
+      ])
+      result = a * b
+      _(result.to_a).must_equal [
+        {symbol: 'BHP', date: '2025-01-01', close: 42.5, volume: 1000},
+        {symbol: 'BHP', date: '2025-01-02', close: 43.0, volume: 1500}
+      ]
+    end
+
+    it "preserves non-shared dimensions from both sides" do
+      result = ohlcv * fundamentals
+      _(result.dimensions).must_equal [:symbol, :date, :close, :pe]
+    end
+
+    it "drops unmatched rows from both sides (inner-join symmetry)" do
+      left = Namo.new([
+        {symbol: 'BHP', close: 42.5},
+        {symbol: 'CBA', close: 100.0}
+      ])
+      right = Namo.new([
+        {symbol: 'BHP', pe: 14.5},
+        {symbol: 'RIO', pe: 9.2}
+      ])
+      result = left * right
+      _(result.to_a).must_equal [{symbol: 'BHP', close: 42.5, pe: 14.5}]
+    end
+
+    it "produces multiplicative duplicates when inputs have duplicates on shared dimensions" do
+      left = Namo.new([
+        {symbol: 'BHP', close: 42.5},
+        {symbol: 'BHP', close: 43.0}
+      ])
+      right = Namo.new([
+        {symbol: 'BHP', pe: 14.5},
+        {symbol: 'BHP', pe: 14.7}
+      ])
+      result = left * right
+      _(result.to_a.length).must_equal 4
+      _(result.to_a).must_equal [
+        {symbol: 'BHP', close: 42.5, pe: 14.5},
+        {symbol: 'BHP', close: 42.5, pe: 14.7},
+        {symbol: 'BHP', close: 43.0, pe: 14.5},
+        {symbol: 'BHP', close: 43.0, pe: 14.7}
+      ]
+    end
+
+    it "carries formulae through from self" do
+      ohlcv[:label] = proc{|r| "#{r[:symbol]}-self"}
+      result = ohlcv * fundamentals
+      _(result.map{|row| row[:label]}).must_equal ['BHP-self', 'RIO-self']
+    end
+
+    it "merges formulae from other" do
+      fundamentals[:flag] = proc{|r| "pe=#{r[:pe]}"}
+      result = ohlcv * fundamentals
+      _(result.map{|row| row[:flag]}).must_equal ['pe=14.5', 'pe=9.2']
+    end
+
+    it "prefers self's formulae on conflict" do
+      ohlcv[:label] = proc{|r| "self: #{r[:symbol]}"}
+      fundamentals[:label] = proc{|r| "other: #{r[:symbol]}"}
+      result = ohlcv * fundamentals
+      _(result.map{|row| row[:label]}).must_equal ['self: BHP', 'self: RIO']
+    end
+
+    it "raises ArgumentError when there are no shared dimensions" do
+      a = Namo.new([{symbol: 'BHP'}])
+      b = Namo.new([{quarter: 'Q1'}])
+      err = _ { a * b }.must_raise ArgumentError
+      _(err.message).must_match(/no shared dimensions, need to have shared dimensions/)
+    end
+
+    it "raises TypeError on a non-Namo operand" do
+      _ { ohlcv * [{symbol: 'BHP'}] }.must_raise TypeError
+    end
+
+    it "returns an instance of self's class" do
+      subclass = Class.new(Namo)
+      a = subclass.new([{symbol: 'BHP', close: 42.5}])
+      b = Namo.new([{symbol: 'BHP', pe: 14.5}])
+      _((a * b).class).must_equal subclass
+    end
+  end
+
+  describe "#**" do
+    let(:products) do
+      Namo.new([{product: 'Widget'}, {product: 'Gadget'}])
+    end
+
+    let(:quarters) do
+      Namo.new([{quarter: 'Q1'}, {quarter: 'Q2'}])
+    end
+
+    it "Cartesian-products two disjoint Namos" do
+      result = products ** quarters
+      _(result.to_a).must_equal [
+        {product: 'Widget', quarter: 'Q1'},
+        {product: 'Widget', quarter: 'Q2'},
+        {product: 'Gadget', quarter: 'Q1'},
+        {product: 'Gadget', quarter: 'Q2'}
+      ]
+    end
+
+    it "has self.data.length * other.data.length rows" do
+      a = Namo.new([{x: 1}, {x: 2}, {x: 3}])
+      b = Namo.new([{y: 'a'}, {y: 'b'}])
+      _((a ** b).to_a.length).must_equal 6
+    end
+
+    it "output dimensions are self.data_dimensions + other.data_dimensions" do
+      result = products ** quarters
+      _(result.dimensions).must_equal [:product, :quarter]
+    end
+
+    it "preserves duplicates on either side multiplicatively" do
+      a = Namo.new([{x: 1}, {x: 1}])
+      b = Namo.new([{y: 'a'}, {y: 'a'}])
+      result = a ** b
+      _(result.to_a.length).must_equal 4
+    end
+
+    it "carries formulae through from self" do
+      products[:label] = proc{|r| "self: #{r[:product]}"}
+      result = products ** quarters
+      _(result.map{|row| row[:label]}).must_equal [
+        'self: Widget', 'self: Widget', 'self: Gadget', 'self: Gadget'
+      ]
+    end
+
+    it "merges formulae from other" do
+      quarters[:flag] = proc{|r| "q=#{r[:quarter]}"}
+      result = products ** quarters
+      _(result.map{|row| row[:flag]}).must_equal ['q=Q1', 'q=Q2', 'q=Q1', 'q=Q2']
+    end
+
+    it "prefers self's formulae on conflict" do
+      products[:label] = proc{|r| "self: #{r[:product]}"}
+      quarters[:label] = proc{|r| "other: #{r[:quarter]}"}
+      result = products ** quarters
+      _(result.map{|row| row[:label]}).must_equal [
+        'self: Widget', 'self: Widget', 'self: Gadget', 'self: Gadget'
+      ]
+    end
+
+    it "raises ArgumentError when any dimension is shared" do
+      a = Namo.new([{symbol: 'BHP', close: 42.5}])
+      b = Namo.new([{symbol: 'RIO', pe: 14.5}])
+      err = _ { a ** b }.must_raise ArgumentError
+      _(err.message).must_match(/dimensions in common, need no common dimensions/)
+    end
+
+    it "raises TypeError on a non-Namo operand" do
+      _ { products ** [{quarter: 'Q1'}] }.must_raise TypeError
+    end
+
+    it "returns an instance of self's class" do
+      subclass = Class.new(Namo)
+      a = subclass.new([{product: 'Widget'}])
+      b = Namo.new([{quarter: 'Q1'}])
+      _((a ** b).class).must_equal subclass
+    end
+  end
+
+  describe "#/" do
+    let(:combined) do
+      Namo.new([
+        {symbol: 'BHP', date: '2025-01-01', close: 42.5, pe: 14.5},
+        {symbol: 'RIO', date: '2025-01-01', close: 118.3, pe: 9.2}
+      ])
+    end
+
+    let(:fundamentals) do
+      Namo.new([
+        {symbol: 'BHP', pe: 14.5},
+        {symbol: 'RIO', pe: 9.2}
+      ])
+    end
+
+    it "removes dimensions present in both self and other (the intersection)" do
+      result = combined / fundamentals
+      _(result.dimensions).must_equal [:date, :close]
+    end
+
+    it "preserves dimensions exclusive to self" do
+      result = combined / fundamentals
+      _(result.to_a).must_equal [
+        {date: '2025-01-01', close: 42.5},
+        {date: '2025-01-01', close: 118.3}
+      ]
+    end
+
+    it "dedupes rows that collide after projection" do
+      a = Namo.new([
+        {symbol: 'BHP', close: 42.5},
+        {symbol: 'RIO', close: 42.5}
+      ])
+      b = Namo.new([{symbol: 'X'}])
+      result = a / b
+      _(result.to_a).must_equal [{close: 42.5}]
+    end
+
+    it "carries formulae through from self" do
+      combined[:label] = proc{|r| "row: #{r[:close]}"}
+      result = combined / fundamentals
+      _(result.map{|row| row[:label]}).must_equal ['row: 42.5', 'row: 118.3']
+    end
+
+    it "is a no-op when self and other share no dimensions" do
+      shipments = Namo.new([{order_id: 1, weight: 10}])
+      weather = Namo.new([{date: '2025-01-01', temperature: 22}])
+      _(shipments / weather).must_equal shipments
+    end
+
+    it "ignores dimensions present in other but not in self" do
+      a = Namo.new([{symbol: 'BHP', close: 42.5}])
+      b = Namo.new([{symbol: 'BHP', pe: 14.5, sector: 'Mining'}])
+      result = a / b
+      _(result.dimensions).must_equal [:close]
+    end
+
+    it "is idempotent" do
+      first = combined / fundamentals
+      second = first / fundamentals
+      _(second).must_equal first
+    end
+
+    it "raises TypeError on a non-Namo operand" do
+      _ { combined / [{symbol: 'BHP'}] }.must_raise TypeError
+    end
+
+    it "returns an instance of self's class" do
+      subclass = Class.new(Namo)
+      a = subclass.new([{symbol: 'BHP', close: 42.5}])
+      b = Namo.new([{symbol: 'BHP', pe: 14.5}])
+      _((a / b).class).must_equal subclass
+    end
+  end
+
+  describe "composition round-trip" do
+    it "satisfies (a ** b) / b == a for disjoint a and b" do
+      a = Namo.new([{symbol: 'BHP'}, {symbol: 'RIO'}])
+      b = Namo.new([{quarter: 'Q1'}, {quarter: 'Q2'}])
+      _((a ** b) / b).must_equal a
+    end
+
+    it "satisfies (a * b) / b == a[-:shared] for a and b with shared dimensions (shared dimensions lost)" do
+      a = Namo.new([{symbol: 'BHP', close: 42.5}, {symbol: 'RIO', close: 118.3}])
+      b = Namo.new([{symbol: 'BHP', pe: 14.5}, {symbol: 'RIO', pe: 9.2}])
+      _((a * b) / b).must_equal Namo.new([{close: 42.5}, {close: 118.3}])
+    end
+  end
+
   describe "#==" do
     it "is true for same data, same order" do
       a = Namo.new([{x: 1}, {x: 2}])

metadata

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