kumi 0.0.16 → 0.0.18

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kumi
 version: !ruby/object:Gem::Version
-  version: 0.0.16
+  version: 0.0.18
 platform: ruby
 authors:
 - André Muta
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-08-22 00:00:00.000000000 Z
+date: 2025-09-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: zeitwerk
@@ -33,13 +33,11 @@ extra_rdoc_files: []
 files:
 - ".rspec"
 - ".rubocop.yml"
-- BACKLOG.md
 - CHANGELOG.md
 - CLAUDE.md
 - LICENSE.txt
 - README.md
 - Rakefile
-- config/functions.yaml
 - docs/AST.md
 - docs/DSL.md
 - docs/FUNCTIONS.md
@@ -58,8 +56,6 @@ files:
 - docs/features/input-declaration-system.md
 - docs/features/performance.md
 - docs/features/s-expression-printer.md
-- docs/functions/analyzer_integration.md
-- docs/functions/signatures.md
 - docs/schema_metadata.md
 - docs/schema_metadata/broadcasts.md
 - docs/schema_metadata/cascades.md
@@ -72,7 +68,6 @@ files:
 - examples/deep_schema_compilation_and_evaluation_benchmark.rb
 - examples/federal_tax_calculator_2024.rb
 - examples/game_of_life.rb
-- examples/hash_objects_demo.rb
 - examples/simple_rpg_game.rb
 - examples/static_analysis_errors.rb
 - examples/wide_schema_compilation_and_evaluation_benchmark.rb
@@ -90,7 +85,6 @@ files:
 - lib/kumi/core/analyzer/passes/broadcast_detector.rb
 - lib/kumi/core/analyzer/passes/declaration_validator.rb
 - lib/kumi/core/analyzer/passes/dependency_resolver.rb
-- lib/kumi/core/analyzer/passes/function_signature_pass.rb
 - lib/kumi/core/analyzer/passes/input_access_planner_pass.rb
 - lib/kumi/core/analyzer/passes/input_collector.rb
 - lib/kumi/core/analyzer/passes/ir_dependency_pass.rb
@@ -104,7 +98,6 @@ files:
 - lib/kumi/core/analyzer/passes/semantic_constraint_validator.rb
 - lib/kumi/core/analyzer/passes/toposorter.rb
 - lib/kumi/core/analyzer/passes/type_checker.rb
-- lib/kumi/core/analyzer/passes/type_consistency_checker.rb
 - lib/kumi/core/analyzer/passes/type_inferencer_pass.rb
 - lib/kumi/core/analyzer/passes/unsat_detector.rb
 - lib/kumi/core/analyzer/passes/visitor_pass.rb
@@ -153,16 +146,6 @@ files:
 - lib/kumi/core/function_registry/stat_functions.rb
 - lib/kumi/core/function_registry/string_functions.rb
 - lib/kumi/core/function_registry/type_functions.rb
-- lib/kumi/core/functions/dimension.rb
-- lib/kumi/core/functions/dtypes.rb
-- lib/kumi/core/functions/errors.rb
-- lib/kumi/core/functions/kernel_adapter.rb
-- lib/kumi/core/functions/loader.rb
-- lib/kumi/core/functions/registry_v2.rb
-- lib/kumi/core/functions/shape.rb
-- lib/kumi/core/functions/signature.rb
-- lib/kumi/core/functions/signature_parser.rb
-- lib/kumi/core/functions/signature_resolver.rb
 - lib/kumi/core/input/type_matcher.rb
 - lib/kumi/core/input/validator.rb
 - lib/kumi/core/input/violation_creator.rb
@@ -206,12 +189,6 @@ files:
 - lib/kumi/frontends.rb
 - lib/kumi/frontends/ruby.rb
 - lib/kumi/frontends/text.rb
-- lib/kumi/kernels/ruby/aggregate_core.rb
-- lib/kumi/kernels/ruby/datetime_scalar.rb
-- lib/kumi/kernels/ruby/mask_scalar.rb
-- lib/kumi/kernels/ruby/scalar_core.rb
-- lib/kumi/kernels/ruby/string_scalar.rb
-- lib/kumi/kernels/ruby/vector_struct.rb
 - lib/kumi/registry.rb
 - lib/kumi/runtime/executable.rb
 - lib/kumi/runtime/run.rb

data/BACKLOG.md

@@ -1,34 +0,0 @@
-# Kumi Development Backlog
-
-## High Priority
-
-### RegistryV2 Migration Cleanup
-- [ ] Remove legacy `lib/kumi/core/function_registry.rb` and related modules after RegistryV2 is fully integrated
-- [ ] Clean up bridge code in `FunctionSignaturePass` once all functions are migrated
-- [ ] Remove `create_basic_signature` fallback logic
-- [ ] Update all tests to use RegistryV2 functions
-
-## Medium Priority
-
-### Function Registry Enhancements
-- [ ] Add YAML linting for function definitions
-- [ ] Implement golden-IR test fixtures for signature resolution
-- [ ] Add Arrow/JS kernel mapping support
-- [ ] Implement type promotion rules from YAML dtypes
-
-### Performance Optimizations
-- [ ] Cache RegistryV2 loading for repeated schema compilations
-- [ ] Optimize signature resolution for large function sets
-- [ ] Implement lazy loading of function kernels
-
-## Low Priority
-
-### Documentation
-- [ ] Auto-generate function reference docs from YAML
-- [ ] Add examples for each function in registry
-- [ ] Document kernel implementation guidelines
-
-### Testing
-- [ ] Add comprehensive NEP-20 compliance test suite
-- [ ] Stress test RegistryV2 with large function sets
-- [ ] Add performance benchmarks for signature resolution

data/config/functions.yaml

@@ -1,352 +0,0 @@
-# ==================== CORE - SCALAR (elementwise) ====================
-
-- name: core.add
-  domain: core
-  opset: 1
-  class: scalar
-  summary: Numeric addition with broadcasting
-  signature: ["(),()->()", "(i),(i)->(i)", "(i,j),(i,j)->(i,j)"]
-  type_vars: {T: Numeric, U: Numeric}
-  dtypes: {result: "promote(T,U)", casting: "same_kind"}
-  null_policy: propagate
-  algebra: {associative: true, commutative: true, identity: 0}
-  vectorization: {mask_aware: true}
-  kernels: 
-    - backend: ruby
-      impl: kumi_add
-      priority: 10
-
-- name: core.sub
-  domain: core
-  opset: 1
-  class: scalar
-  signature: ["(),()->()", "(i),(i)->(i)", "(i,j),(i,j)->(i,j)"]
-  type_vars: {T: Numeric, U: Numeric}
-  dtypes: {result: "promote(T,U)", casting: "same_kind"}
-  null_policy: propagate
-  kernels:
-    - backend: ruby
-      impl: kumi_sub
-      priority: 10
-
-- name: core.mul
-  domain: core
-  opset: 1
-  class: scalar
-  signature: ["(),()->()", "(i),(i)->(i)", "(i,j),(i,j)->(i,j)"]
-  type_vars: {T: Numeric, U: Numeric}
-  dtypes: {result: "promote(T,U)", casting: "same_kind"}
-  null_policy: propagate
-  algebra: {associative: true, commutative: true, identity: 1, annihilator: 0}
-  kernels:
-    - backend: ruby
-      impl: kumi_mul
-      priority: 10
-
-- name: core.div
-  domain: core
-  opset: 1
-  class: scalar
-  signature: ["(),()->()", "(i),(i)->(i)", "(i,j),(i,j)->(i,j)"]
-  type_vars: {T: Numeric, U: Numeric}
-  dtypes: {result: "promote_float(T,U)", casting: "same_kind"}
-  null_policy: propagate
-  kernels:
-    - backend: ruby
-      impl: kumi_div
-      priority: 10
-
-- name: core.eq
-  domain: core
-  opset: 1
-  class: scalar
-  signature: ["(),()->()", "(i),(i)->(i)", "(i,j),(i,j)->(i,j)"]
-  type_vars: {T: Any, U: Any}
-  dtypes: {result: "bool"}
-  null_policy: propagate
-  algebra: {idempotent: true}
-  kernels:
-    - backend: ruby
-      impl: kumi_eq
-      priority: 10
-
-- name: core.gt
-  domain: core
-  opset: 1
-  class: scalar
-  signature: ["(),()->()", "(i),(i)->(i)"]
-  type_vars: {T: Orderable, U: Orderable}
-  dtypes: {result: "bool"}
-  null_policy: propagate
-  kernels:
-    - backend: ruby
-      impl: kumi_gt
-      priority: 10
-
-- name: core.gte
-  domain: core
-  opset: 1
-  class: scalar
-  signature: ["(),()->()", "(i),(i)->(i)"]
-  type_vars: {T: Orderable, U: Orderable}
-  dtypes: {result: "bool"}
-  null_policy: propagate
-  kernels:
-    - backend: ruby
-      impl: kumi_gte
-      priority: 10
-
-- name: core.and
-  domain: core
-  opset: 1
-  class: scalar
-  signature: ["(),()->()", "(i),(i)->(i)"]
-  type_vars: {B1: Bool, B2: Bool}
-  dtypes: {result: "bool"}
-  null_policy: propagate
-  algebra: {associative: true, commutative: true, identity: true, annihilator: false}
-  vectorization: {short_circuit: left_to_right, mask_aware: true}
-  kernels:
-    - backend: ruby
-      impl: kumi_and
-      priority: 10
-
-- name: core.or
-  domain: core
-  opset: 1
-  class: scalar
-  signature: ["(),()->()", "(i),(i)->(i)"]
-  type_vars: {B1: Bool, B2: Bool}
-  dtypes: {result: "bool"}
-  null_policy: propagate
-  algebra: {associative: true, commutative: true, identity: false, annihilator: true}
-  vectorization: {short_circuit: left_to_right, mask_aware: true}
-  kernels:
-    - backend: ruby
-      impl: kumi_or
-      priority: 10
-
-- name: core.not
-  domain: core
-  opset: 1
-  class: scalar
-  signature: ["()->()", "(i)->(i)"]
-  type_vars: {B: Bool}
-  dtypes: {result: "bool"}
-  null_policy: propagate
-  kernels:
-    - backend: ruby
-      impl: kumi_not
-      priority: 10
-
-# ==================== AGGREGATES (reduce last axis in signature) ==============
-
-- name: agg.sum
-  domain: core
-  opset: 1
-  class: aggregate
-  signature: ["(i)->()", "(i,j)->(i)"]
-  type_vars: {T: Numeric}
-  dtypes: {result: "promote(T)"}
-  null_policy: skip
-  options: {min_count: 0}
-  algebra: {associative: true, commutative: true, identity: 0}
-  kernels:
-    - backend: ruby
-      impl: kumi_sum
-      priority: 10
-
-- name: agg.min
-  domain: core
-  opset: 1
-  class: aggregate
-  signature: ["(i)->()", "(i,j)->(i)"]
-  type_vars: {T: Orderable}
-  dtypes: {result: "T"}
-  null_policy: skip
-  kernels:
-    - backend: ruby
-      impl: kumi_min
-      priority: 10
-
-- name: agg.max
-  domain: core
-  opset: 1
-  class: aggregate
-  signature: ["(i)->()", "(i,j)->(i)"]
-  type_vars: {T: Orderable}
-  dtypes: {result: "T"}
-  null_policy: skip
-  kernels:
-    - backend: ruby
-      impl: kumi_max
-      priority: 10
-
-- name: agg.mean
-  domain: core
-  opset: 1
-  class: aggregate
-  signature: ["(i)->()", "(i,j)->(i)"]
-  type_vars: {T: Numeric}
-  dtypes: {result: "float"}
-  null_policy: skip
-  options: {min_count: 0}
-  kernels:
-    - backend: ruby
-      impl: kumi_mean
-      priority: 10
-
-# ==================== STRUCTURE / SHAPE / JOIN ================================
-
-- name: struct.join
-  domain: struct
-  opset: 1
-  class: structure
-  summary: Align inputs by axes using zip or product
-  signature: ["(i),(i)->(i)@zip", "(i),(j)->(i,j)@product"]
-  null_policy: error_on_missing
-  kernels:
-    - backend: ruby
-      impl: join_zip
-      when: {policy: zip}
-      priority: 10
-    - backend: ruby
-      impl: join_product
-      when: {policy: product}
-      priority: 10
-
-- name: struct.align_to
-  domain: struct
-  opset: 1
-  class: structure
-  signature: ["(i)->(i)", "(i,j)->(i,j)"]
-  traits: {reorders: false}
-  null_policy: error_on_missing
-  kernels:
-    - backend: ruby
-      impl: align_to
-      priority: 10
-
-- name: struct.lift
-  domain: struct
-  opset: 1
-  class: structure
-  signature: ["(i)->(i)", "(i,j)->(i,j)"]
-  summary: Group flat rows back to nested collections based on indices
-  kernels:
-    - backend: ruby
-      impl: lift
-      priority: 10
-
-- name: struct.flatten
-  domain: struct
-  opset: 1
-  class: structure
-  signature: ["(i,j)->(k)"]
-  shape_fn: "flatten_axes(i,j)->k"
-  kernels:
-    - backend: ruby
-      impl: flatten
-      priority: 10
-
-- name: struct.take
-  domain: struct
-  opset: 1
-  class: structure
-  signature: ["(i),(i)->(i)"]  # take(values, indices) elemwise
-  type_vars: {T: Any}
-  dtypes: {result: "T"}
-  null_policy: error
-  kernels:
-    - backend: ruby
-      impl: take
-      priority: 10
-
-- name: struct.size
-  domain: struct
-  opset: 1
-  class: vector
-  signature: ["(i)->()", "(i,j)->()"]
-  dtypes: {result: "int"}
-  null_policy: error
-  kernels:
-    - backend: ruby
-      impl: size
-      priority: 10
-
-# ==================== MASK / CONDITIONAL ======================================
-
-- name: mask.where
-  domain: mask
-  opset: 1
-  class: scalar
-  summary: Ternary select with broadcasting of then/else
-  signature:
-    - "(i),(i),(i)->(i)"
-    - "(i),(),()->(i)"
-    - "(),(i),()->(i)"
-    - "(),(),()->()"
-  type_vars: {B: Bool, T: Any, U: Any}
-  dtypes: {result: "unify(T,U)"}
-  null_policy: propagate
-  vectorization: {mask_aware: true, short_circuit: left_to_right}
-  kernels:
-    - backend: ruby
-      impl: where
-      priority: 10
-
-# ==================== STRING (minimal) ========================================
-
-- name: string.concat
-  domain: string
-  opset: 1
-  class: scalar
-  signature: ["(),()->()", "(i),(i)->(i)"]
-  type_vars: {S1: String, S2: String}
-  dtypes: {result: "string"}
-  null_policy: propagate
-  kernels:
-    - backend: ruby
-      impl: str_concat
-      priority: 10
-
-- name: string.length
-  domain: string
-  opset: 1
-  class: vector
-  signature: ["(i)->(i)", "()->()"]
-  type_vars: {S: String}
-  dtypes: {result: "int"}
-  null_policy: propagate
-  kernels:
-    - backend: ruby
-      impl: str_length
-      priority: 10
-
-# ==================== DATETIME (minimal) ======================================
-
-- name: datetime.add_days
-  domain: datetime
-  opset: 1
-  class: scalar
-  signature: ["(),()->()", "(i),(i)->(i)"]
-  type_vars: {D: DateLike, N: IntLike}
-  dtypes: {result: "datetime"}
-  null_policy: propagate
-  kernels:
-    - backend: ruby
-      impl: dt_add_days
-      priority: 10
-
-- name: datetime.diff_days
-  domain: datetime
-  opset: 1
-  class: scalar
-  signature: ["(),()->()", "(i),(i)->(i)"]
-  type_vars: {D1: DateLike, D2: DateLike}
-  dtypes: {result: "int"}
-  null_policy: propagate
-  kernels:
-    - backend: ruby
-      impl: dt_diff_days
-      priority: 10

data/docs/functions/analyzer_integration.md

@@ -1,199 +0,0 @@
-# Function Signature Analysis Integration
-
-This document describes how NEP-20 function signatures integrate with Kumi's multi-pass analyzer architecture.
-
-## Architecture Overview
-
-Function signature resolution is integrated into the analyzer pipeline through a node index system that allows passes to share metadata efficiently.
-
-```
-┌─────────────────┐    ┌──────────────────────┐    ┌────────────────────┐
-│   Toposorter    │───▶│ FunctionSignaturePass │───▶│   LowerToIRPass    │
-│ Creates node    │    │ Resolves signatures   │    │ Validates metadata │
-│ index by ID     │    │ Attaches metadata     │    │ Emits IR ops       │
-└─────────────────┘    └──────────────────────┘    └────────────────────┘
-```
-
-## Node Index System
-
-### Creation (Toposorter)
-
-The `Toposorter` pass creates a comprehensive index of all nodes in the AST:
-
-```ruby
-# State structure after Toposorter
-state[:node_index] = {
-  object_id_1 => {
-    node: CallExpression_instance,
-    type: "CallExpression",
-    metadata: {}
-  },
-  # ... more nodes
-}
-```
-
-### Population (FunctionSignaturePass)
-
-The `FunctionSignaturePass` populates metadata for `CallExpression` nodes:
-
-```ruby
-# After FunctionSignaturePass
-entry[:metadata] = {
-  signature: Signature_object,           # Full signature object
-  result_axes: [:i, :j],                # Output dimension names  
-  join_policy: :zip,                    # Cross-dimensional policy
-  dropped_axes: [:k],                   # Dimensions eliminated by reductions
-  effective_signature: {                # Normalized for lowering
-    in_shapes: [[:i, :k], [:k, :j]],
-    out_shape: [:i, :j], 
-    join_policy: :zip
-  },
-  dim_env: { i: :i, j: :j, k: :k },    # Dimension variable bindings
-  shape_contract: {                     # Simplified for lowering
-    in: [[:i, :k], [:k, :j]],
-    out: [:i, :j],
-    join: :zip
-  },
-  signature_score: 0                    # Match quality (0 = exact)
-}
-```
-
-### Consumption (LowerToIRPass)
-
-The lowering pass validates and uses the signature metadata:
-
-```ruby
-def validate_signature_metadata(expr, entry)
-  node_index = get_state(:node_index)
-  metadata = node_index[expr.object_id][:metadata]
-  
-  # Validate dropped axes for reductions
-  if entry&.reducer && metadata[:dropped_axes]
-    # Assert axis exists in scope
-  end
-  
-  # Warn about join policies not yet implemented
-  if metadata[:join_policy]
-    # Log warning or feature flag check
-  end
-end
-```
-
-## Pass Integration Points
-
-### 1. Signature Resolution
-
-**Location**: After `BroadcastDetector`, before `TypeChecker`
-
-**Purpose**: Resolve NEP-20 signatures for all function calls
-
-**Input**: 
-- Node index from Toposorter
-- Broadcast metadata (optional)
-- Current function registry
-
-**Output**: Rich signature metadata attached to call nodes
-
-### 2. Type Checking Enhancement
-
-**Integration**: `TypeChecker` can now use signature metadata for enhanced validation:
-
-```ruby
-def validate_function_call(node, errors)
-  # Get resolved signature metadata
-  node_entry = node_index[node.object_id]
-  if node_entry && node_entry[:metadata][:signature]
-    # Use NEP-20 signature for validation
-    validate_nep20_signature(node, node_entry[:metadata], errors)
-  else
-    # Fall back to legacy registry-based validation
-    validate_legacy_signature(node, errors)
-  end
-end
-```
-
-### 3. Lowering Integration
-
-**Integration**: `LowerToIRPass` validates signature consistency and emits appropriate IR:
-
-```ruby  
-when Syntax::CallExpression
-  entry = Kumi::Registry.entry(expr.fn_name)
-  validate_signature_metadata(expr, entry)  # Read-only validation
-  
-  # Use shape contract for IR generation
-  if node_entry = node_index[expr.object_id]
-    contract = node_entry[:metadata][:shape_contract]
-    # Use contract to emit appropriate reduce/join ops
-  end
-```
-
-## Metadata Contract
-
-All passes can rely on this metadata structure for `CallExpression` nodes:
-
-| Field | Type | Description |
-|-------|------|-------------|
-| `:signature` | `Signature` | Full signature object with dimensions |
-| `:result_axes` | `Array<Symbol>` | Output dimension names |
-| `:join_policy` | `Symbol?` | `:zip`, `:product`, or `nil` |
-| `:dropped_axes` | `Array<Symbol>` | Dimensions eliminated (reductions) |
-| `:effective_signature` | `Hash` | Normalized signature for lowering |
-| `:dim_env` | `Hash` | Dimension variable bindings |
-| `:shape_contract` | `Hash` | Simplified contract for IR generation |
-| `:signature_score` | `Integer` | Match quality (0 = exact) |
-
-## Error Handling
-
-Enhanced error messages include signature information:
-
-```ruby
-# Before
-"operator `multiply` expects 2 args, got 3"
-
-# After  
-"Signature mismatch for `multiply` with args (i,j), (k). 
- Candidates: (),()->() | (i),(i)->(i). 
- no matching signature for shapes (i,j), (k)"
-```
-
-## Feature Flags
-
-Control NEP-20 behavior at runtime:
-
-```bash
-export KUMI_ENABLE_FLEX=1    # Enable flexible dimension matching (?)
-export KUMI_ENABLE_BCAST1=1  # Enable broadcastable matching (|1)  
-```
-
-## Future Extensions
-
-The node index architecture supports future enhancements:
-
-### Registry V2 Integration
-```ruby
-# Read signatures from YAML registry
-signatures = RegistryV2.get_function_signatures(node.fn_name)
-```
-
-### Type System Integration
-```ruby
-# Add dtype metadata alongside shape metadata
-metadata[:result_dtype] = infer_result_dtype(args, signature)
-```
-
-### Optimization Metadata
-```ruby
-# Add optimization hints
-metadata[:can_vectorize] = true
-metadata[:memory_access_pattern] = :sequential
-```
-
-## Performance Considerations
-
-- **Node index creation**: O(n) where n = total AST nodes
-- **Signature resolution**: O(k*m) where k = signatures, m = arguments  
-- **Memory overhead**: ~100 bytes per CallExpression node
-- **Pass integration**: Zero performance impact on existing passes
-
-The architecture is designed for extensibility while maintaining backward compatibility with the existing analyzer pipeline.