kumi 0.0.9 → 0.0.11

data/lib/kumi/core/function_registry.rb

@@ -2,135 +2,175 @@
 
 module Kumi
   module Core
-    # Registry for functions that can be used in Kumi schemas
-    # This is the public interface for registering custom functions
+    # Internal function registry (single source of truth).
     module FunctionRegistry
-      # Re-export the Entry struct from FunctionBuilder for compatibility
       Entry = FunctionBuilder::Entry
 
-      # Core operators that are always available
       CORE_OPERATORS = %i[== > < >= <= != between?].freeze
 
-      # Build the complete function registry by combining all categories
+      # Build core functions once
       CORE_FUNCTIONS = {}.tap do |registry|
-        registry.merge!(ComparisonFunctions.definitions)
-        registry.merge!(MathFunctions.definitions)
-        registry.merge!(StringFunctions.definitions)
-        registry.merge!(LogicalFunctions.definitions)
-        registry.merge!(CollectionFunctions.definitions)
-        registry.merge!(ConditionalFunctions.definitions)
-        registry.merge!(TypeFunctions.definitions)
+        [
+          ComparisonFunctions.definitions,
+          MathFunctions.definitions,
+          StringFunctions.definitions,
+          LogicalFunctions.definitions,
+          CollectionFunctions.definitions,
+          ConditionalFunctions.definitions,
+          TypeFunctions.definitions,
+          StatFunctions.definitions
+        ].each do |defs|
+          defs.each do |name, entry|
+            raise ArgumentError, "Duplicate core function: #{name}" if registry.key?(name)
+
+            registry[name] = entry
+          end
+        end
       end.freeze
 
-      @functions = CORE_FUNCTIONS.dup
-      @frozen = false
+      @lock      = Mutex.new
+      @functions = CORE_FUNCTIONS.transform_values(&:dup)
+      @frozen    = false
 
-      # class << self
-      # Public interface for registering custom functions
-      def register(name, &block)
-        raise ArgumentError, "Function #{name.inspect} already registered" if @functions.key?(name)
+      class FrozenError < RuntimeError; end
 
-        fn_lambda = block.is_a?(Proc) ? block : ->(*args) { yield(*args) }
-        register_with_metadata(name, fn_lambda, arity: fn_lambda.arity, param_types: [:any], return_type: :any)
-      end
-
-      # Register with custom metadata
-      def register_with_metadata(name, fn_lambda, arity:, param_types: [:any], return_type: :any, description: nil,
-                                 inverse: nil, reducer: false)
-        raise ArgumentError, "Function #{name.inspect} already registered" if @functions.key?(name)
-
-        @functions[name] = Entry.new(
-          fn: fn_lambda,
-          arity: arity,
-          param_types: param_types,
-          return_type: return_type,
-          description: description,
-          inverse: inverse,
-          reducer: reducer
-        )
-      end
+      class << self
+        def auto_register(*mods)
+          mods.each do |mod|
+            mod.public_instance_methods(false).each do |m|
+              next if function?(m)
 
-      # Auto-register functions from modules
-      def auto_register(*modules)
-        modules.each do |mod|
-          mod.public_instance_methods(false).each do |method_name|
-            next if supported?(method_name)
+              register(m) { |*args| mod.new.public_send(m, *args) }
+            end
+            mod.singleton_methods(false).each do |m|
+              next if function?(m)
 
-            register(method_name) do |*args|
-              mod.new.public_send(method_name, *args)
+              fn = mod.method(m)
+              register(m) { |*args| fn.call(*args) }
             end
           end
         end
-      end
 
-      # Query interface
-      def supported?(name)
-        @functions.key?(name)
-      end
+        #
+        # Lifecycle
+        #
+        def reset!
+          @lock.synchronize do
+            @functions = CORE_FUNCTIONS.transform_values(&:dup)
+            @frozen    = false
+          end
+        end
 
-      def operator?(name)
-        return false unless name.is_a?(Symbol)
+        def freeze!
+          @lock.synchronize do
+            @functions.each_value(&:freeze)
+            @functions.freeze
+            @frozen = true
+          end
+        end
 
-        @functions.key?(name) && CORE_OPERATORS.include?(name)
-      end
+        def frozen?
+          @frozen
+        end
 
-      def fetch(name)
-        @functions.fetch(name) { raise Kumi::Errors::UnknownFunction, "Unknown function: #{name}" }.fn
-      end
+        #
+        # Registration
+        #
+        # Unified entry point; used by both public and internal callers.
+        def register(name, fn_or = nil, **meta, &block)
+          fn = fn_or || block
+          raise ArgumentError, "block or Proc required" unless fn.is_a?(Proc)
+
+          defaults = {
+            arity: fn.arity,
+            param_types: [:any],
+            return_type: :any,
+            description: nil,
+            param_modes: nil,
+            reducer: false,
+            structure_function: false
+          }
+          register_with_metadata(name, fn, **defaults, **meta)
+        end
 
-      def signature(name)
-        entry = @functions.fetch(name) { raise Kumi::Errors::UnknownFunction, "Unknown function: #{name}" }
-        {
-          arity: entry.arity,
-          param_types: entry.param_types,
-          return_type: entry.return_type,
-          description: entry.description
-        }
-      end
+        # Back-compat explicit API
+        def register_with_metadata(name, fn, arity:, param_types: [:any], return_type: :any,
+                                   description: nil, param_modes: nil, reducer: false,
+                                   structure_function: false)
+          @lock.synchronize do
+            raise FrozenError, "registry is frozen" if @frozen
+            raise ArgumentError, "Function #{name.inspect} already registered" if @functions.key?(name)
+
+            @functions[name] = Entry.new(
+              fn: fn,
+              arity: arity,
+              param_types: param_types,
+              return_type: return_type,
+              description: description,
+              param_modes: param_modes,
+              reducer: reducer,
+              structure_function: structure_function
+            )
+          end
+        end
 
-      def all_functions
-        @functions.keys
-      end
+        #
+        # Queries
+        #
+        def function?(name)
+          @functions.key?(name)
+        end
+        alias supported? function?
 
-      def reducer?(name)
-        entry = @functions.fetch(name) { return false }
-        entry.reducer || false
-      end
+        def operator?(name)
+          name.is_a?(Symbol) && function?(name) && CORE_OPERATORS.include?(name)
+        end
 
-      # Alias for compatibility
-      def all
-        @functions.keys
-      end
+        def entry(name)
+          @functions[name]
+        end
 
-      # Category accessors for introspection
-      def comparison_operators
-        ComparisonFunctions.definitions.keys
-      end
+        def fetch(name)
+          ent = entry(name)
+          raise Kumi::Errors::UnknownFunction, "Unknown function: #{name}" unless ent
 
-      def math_operations
-        MathFunctions.definitions.keys
-      end
+          ent.fn
+        end
 
-      def string_operations
-        StringFunctions.definitions.keys
-      end
+        def signature(name)
+          ent = entry(name) or raise Kumi::Errors::UnknownFunction, "Unknown function: #{name}"
+          { arity: ent.arity, param_types: ent.param_types, return_type: ent.return_type, description: ent.description }
+        end
 
-      def logical_operations
-        LogicalFunctions.definitions.keys
-      end
+        def reducer?(name)
+          ent = entry(name)
+          ent ? !!ent.reducer : false
+        end
 
-      def collection_operations
-        CollectionFunctions.definitions.keys
-      end
+        def structure_function?(name)
+          ent = entry(name)
+          ent ? !!ent.structure_function : false
+        end
 
-      def conditional_operations
-        ConditionalFunctions.definitions.keys
-      end
+        def all_functions
+          @functions.keys
+        end
+        alias all all_functions
+
+        def functions
+          @functions.dup
+        end
 
-      def type_operations
-        TypeFunctions.definitions.keys
+        # Introspection helpers
+        def comparison_operators   = ComparisonFunctions.definitions.keys
+        def math_operations        = MathFunctions.definitions.keys
+        def string_operations      = StringFunctions.definitions.keys
+        def logical_operations     = LogicalFunctions.definitions.keys
+        def collection_operations  = CollectionFunctions.definitions.keys
+        def conditional_operations = ConditionalFunctions.definitions.keys
+        def type_operations        = TypeFunctions.definitions.keys
+        def stat_operations        = StatFunctions.definitions.keys
       end
     end
   end
 end
-# end

data/lib/kumi/core/ir/execution_engine/combinators.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module IR
+      module ExecutionEngine
+        # Pure combinators for data transformation
+        module Combinators
+          # Broadcast scalar over vec (scalar→vec only)
+          # @param s [Hash] scalar value {:k => :scalar, :v => value}
+          # @param v [Hash] vector value {:k => :vec, :scope => [...], :rows => [...]}
+          # @return [Hash] broadcasted vector
+          def self.broadcast_scalar(s, v)
+            raise "First arg must be scalar" unless s[:k] == :scalar
+            raise "Second arg must be vec" unless v[:k] == :vec
+
+            rows = v[:rows].map do |r|
+              r.key?(:idx) ? { v: s[:v], idx: r[:idx] } : { v: s[:v] }
+            end
+
+            Values.vec(v[:scope], rows, v[:has_idx])
+          end
+
+          # Positional zip for same-scope vecs
+          # @param vecs [Array<Hash>] vectors to zip together
+          # @return [Hash] zipped vector
+          def self.zip_same_scope(*vecs)
+            raise "All arguments must be vecs" unless vecs.all? { |v| v[:k] == :vec }
+            raise "All vecs must have same scope" unless vecs.map { |v| v[:scope] }.uniq.size == 1
+            raise "All vecs must have same row count" unless vecs.map { |v| v[:rows].size }.uniq.size == 1
+            return vecs.first if vecs.length == 1
+
+            first_vec = vecs.first
+            zipped_rows = first_vec[:rows].zip(*vecs[1..].map { |v| v[:rows] }).map do |row_group|
+              combined_values = row_group.map { |r| r[:v] }
+              result_row = { v: combined_values }
+              result_row[:idx] = row_group.first[:idx] if row_group.first.key?(:idx)
+              result_row
+            end
+
+            Values.vec(first_vec[:scope], zipped_rows, first_vec[:has_idx])
+          end
+
+          # Prefix-index alignment for rank expansion/broadcasting
+          # @param tgt [Hash] target vector (defines output structure)
+          # @param src [Hash] source vector (values to align)
+          # @param to_scope [Array] target scope
+          # @param require_unique [Boolean] enforce unique prefixes
+          # @param on_missing [Symbol] :error or :nil policy
+          # @return [Hash] aligned vector
+          def self.align_to(tgt, src, to_scope:, require_unique: false, on_missing: :error)
+            raise "align_to expects vecs with indices" unless [tgt, src].all? { |v| v[:k] == :vec && v[:has_idx] }
+
+            to_rank = to_scope.length
+            src_rank = src[:rows].first[:idx].length
+            raise "scope not prefix-compatible: #{src_rank} > #{to_rank}" unless src_rank <= to_rank
+
+            # Build prefix->value hash
+            h = {}
+            src[:rows].each do |r|
+              k = r[:idx].first(src_rank)
+              raise "non-unique prefix for align_to: #{k.inspect}" if require_unique && h.key?(k)
+
+              h[k] = r[:v]
+            end
+
+            # Map target rows through alignment
+            rows = tgt[:rows].map do |r|
+              k = r[:idx].first(src_rank)
+              if h.key?(k)
+                { v: h[k], idx: r[:idx] }
+              else
+                case on_missing
+                when :nil then { v: nil, idx: r[:idx] }
+                when :error then raise "missing prefix #{k.inspect} in align_to"
+                else raise "unknown on_missing policy: #{on_missing}"
+                end
+              end
+            end
+
+            Values.vec(to_scope, rows, true)
+          end
+
+          # Build hierarchical groups for lift operation
+          # @param rows [Array<Hash>] rows with indices
+          # @param depth [Integer] nesting depth
+          # @return [Array] nested array structure
+          # rows: [{ v: ..., idx: [i0,i1,...] }, ...] with lexicographically sorted :idx
+          def self.group_rows(rows, depth = 0)
+            return [] if rows.empty?
+            raise ArgumentError, "depth < 0" if depth < 0
+
+            if depth == 0
+              return rows.first[:v] if rows.first[:idx].nil? || rows.first[:idx].empty?
+
+              return rows.map { |r| r[:v] }
+            end
+
+            out = []
+            i = 0
+            n = rows.length
+            while i < n
+              head = rows[i][:idx].first
+              j = i + 1
+              j += 1 while j < n && rows[j][:idx].first == head
+
+              tail = rows[i...j].map { |r| { v: r[:v], idx: r[:idx][1..-1] } }
+              out << group_rows(tail, depth - 1)
+              i = j
+            end
+            out
+          end
+        end
+      end
+    end
+  end
+end