kumi 0.0.18 → 0.0.20

data/lib/kumi/core/compiler/access_planner.rb

@@ -71,7 +71,7 @@ module Kumi
 
           list = (@plans[base[:path]] ||= [])
           modes.each do |mode|
-            operations = build_operations(path, mode)
+            operations = build_operations(path, mode, base[:containers])
 
             list << Kumi::Core::Analyzer::Structs::AccessPlan.new(
               path: base[:path],
@@ -82,7 +82,8 @@ module Kumi
               mode: mode, # :read | :each_indexed | :materialize | :ravel
               on_missing: base[:on_missing],
               key_policy: base[:key_policy],
-              operations: operations
+              operations: operations[:operations],
+              chain: operations[:chain]
             )
           end
         end
@@ -105,10 +106,12 @@ module Kumi
         end
 
         # Core op builder: apply the parent→child edge rule per segment.
-        def build_operations(path, mode)
+        def build_operations(path, mode, containers)
           ops = []
+          chain = []
           parent_meta = nil
           cur = @meta
+          container_index = 0
 
           puts "\n🔨 Building operations for path: #{path.join('.')}:#{mode}" if ENV["DEBUG_ACCESSOR_OPS"]
 
@@ -137,6 +140,22 @@ module Kumi
               if enter_via == :hash
                 ops << enter_hash(seg)
                 puts "      Added: enter_hash('#{seg}')" if ENV["DEBUG_ACCESSOR_OPS"]
+
+                # Add to chain: subsequent array accesses are array_element
+                if container_index < containers.size
+                  chain << {
+                    "kind" => "array_element",
+                    "alias" => seg,
+                    "axis" => containers[container_index].to_s
+                  }
+                  container_index += 1
+                else
+                  # This is the final scalar
+                  chain << {
+                    "kind" => "scalar_leaf",
+                    "key" => seg
+                  }
+                end
               elsif enter_via == :array
                 # Inline alias, no hash operation needed
                 puts "      Skipped enter_hash (inline alias)" if ENV["DEBUG_ACCESSOR_OPS"]
@@ -147,6 +166,24 @@ module Kumi
               # Root, object, or hash parent - always emit enter_hash
               ops << enter_hash(seg)
               puts "      Added: enter_hash('#{seg}')" if ENV["DEBUG_ACCESSOR_OPS"]
+
+              # Add to chain: check if this segment corresponds to an array container
+              node_container = node[:container]
+              if node_container == :array && container_index < containers.size
+                # This is array_field (named field containing array)
+                chain << {
+                  "kind" => "array_field",
+                  "key" => seg,
+                  "axis" => containers[container_index].to_s
+                }
+                container_index += 1
+              else
+                # This is scalar_leaf (final scalar)
+                chain << {
+                  "kind" => "scalar_leaf",
+                  "key" => seg
+                }
+              end
             else
               raise ArgumentError,
                     "Invalid parent :container '#{container}' for segment '#{seg}'. Expected :array, :object, :hash, or nil (root)"
@@ -165,8 +202,9 @@ module Kumi
 
           # # If we land on an array and this mode iterates elements, step into it.
           puts "  Final operations: #{ops.inspect}" if ENV["DEBUG_ACCESSOR_OPS"]
+          puts "  Final chain: #{chain.inspect}" if ENV["DEBUG_ACCESSOR_OPS"]
 
-          ops
+          { operations: ops, chain: chain }
         end
 
         def container_lineage(path)

data/lib/kumi/core/compiler/access_planner_v2.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module Compiler
+      class AccessPlannerV2
+        attr_reader :plans, :index_table
+
+        DEFAULTS = { on_missing: :error, key_policy: :indifferent }.freeze
+        def self.plan(meta, options = {}, debug_on: false) = new(meta, options, debug_on:).plan
+
+        def initialize(meta, options = {}, debug_on: false)
+          @meta         = meta
+          @debug_on     = debug_on
+          @defaults     = DEFAULTS.merge(options.transform_keys(&:to_sym))
+          @plans        = []
+          @index_table  = {}
+        end
+
+        def plan
+          @meta.each do |root_name, node|
+            # Synthetic hop: implicit root hash → reach declared root by key
+            steps = [{ kind: :property_access, key: root_name.to_s }]
+            axes  = []
+
+            # If the root itself is an array, open its loop at the root axis
+            if node.container == :array
+              steps << { kind: :array_loop, axis: root_name.to_s }
+              axes  << root_name.to_sym
+            end
+
+            # Emit normal plan for the root node
+            node_axes = [] # The root axes are always [], e.g. array :x (the container :x opens [:x], but is not inside that dim)
+            walk([root_name.to_s], node, steps, axes, steps, [])
+
+            # If the root array defines an index, emit a *synthetic* index plan now
+            next unless node.container == :array && node.define_index
+
+            emit_index_plan!(
+              idx_name: node.define_index,
+              fqn_prefix: root_name.to_s,
+              axes: axes.dup,
+              steps: steps.dup
+            )
+          end
+
+          @plans.sort_by! { |p| p.path_fqn }
+          self
+        end
+
+        private
+
+        def debug(msg)
+          return unless @debug_on
+
+          puts msg
+        end
+
+        def walk(path_segs, node, steps_so_far, axes_so_far, node_steps = nil, node_axes = nil)
+          fqn   = path_segs.join(".")
+          axes  = node_axes || axes_so_far
+          steps = node_steps || steps_so_far
+
+          axes_str   = "[#{axes.join(', ')}]"
+          steps_desc = steps.map do |s|
+            case s[:kind]
+            when :property_access then ".#{s[:key]}"
+            when :element_access  then "[]"
+            when :array_loop      then "loop(#{s[:axis]})"
+            end
+          end.join(" ")
+
+          override_marker = node_axes || node_steps ? " [OVERRIDE]" : ""
+          debug "#{fqn} | axes: #{axes_str} | dtype: #{node.type}#{override_marker}"
+          debug "   steps: #{steps_desc}" unless steps.empty?
+
+          @plans << Core::Analyzer::Plans::InputPlan.new(
+            source_path: path_segs.map(&:to_sym),
+            axes: axes,
+            dtype: node.type,
+            key_policy: @defaults[:key_policy],
+            missing_policy: @defaults[:on_missing],
+            navigation_steps: steps,
+            path_fqn: fqn,
+            open_axis: axes.size < axes_so_far.size
+          )
+
+          return unless node.children && !node.children.empty?
+
+          node.children.each do |cname, child|
+            edge_steps = node.child_steps.fetch(cname.to_sym)
+            edge_desc  = edge_steps.map { |s| s[:kind] == :array_loop ? "loop(#{s[:axis]})" : s[:kind].to_s.split("_").first }.join(" → ")
+            debug "   ↳ #{cname}: #{edge_desc}"
+
+            new_steps = steps_so_far + edge_steps
+            new_axes  = axes_so_far.dup
+            new_axes << cname.to_sym if edge_steps.any? { |s| (s[:kind] || s["kind"]) == :array_loop }
+
+            # If the child is an array with a declared index, emit its synthetic index plan
+            if child.container == :array && child.define_index
+              emit_index_plan!(
+                idx_name: child.define_index,
+                fqn_prefix: "#{fqn}.#{cname}",
+                axes: new_axes.dup,
+                steps: new_steps.dup
+              )
+            end
+
+            # OVERRIDE: for array containers, the container node itself is *not* in the child axis.
+            child_node_axes  = nil
+            child_node_steps = nil
+            if edge_steps.last && edge_steps.last[:kind] == :array_loop &&
+               edge_steps.last[:axis].to_s == cname.to_s &&
+               child.container == :array
+              child_node_axes  = new_axes[0...-1]
+              child_node_steps = new_steps[0...-1]
+              debug "      [OVERRIDE] Array container detected: dropping last axis/step for #{cname}"
+              debug "         axes before:  #{new_axes.inspect}"
+              debug "         axes after:   #{child_node_axes.inspect}"
+              debug "         steps before: #{new_steps.inspect}"
+              debug "         steps after:  #{child_node_steps.inspect}"
+            end
+
+            walk(path_segs + [cname.to_s], child, new_steps, new_axes, child_node_steps, child_node_axes)
+          end
+        end
+
+        # --- Synthetic index plan emitter ---
+        #
+        # For an axis index declared on an array node, we create a synthetic path:
+        #   "#{fqn_prefix}.__index(<name>)"
+        # Its steps mirror "being at the element" of that loop, so we append an :element_access.
+        # Axes are exactly the axes of the array *element* (i.e., including this axis).
+        #
+        def emit_index_plan!(idx_name:, fqn_prefix:, axes:, steps:)
+          idx_fqn   = "#{fqn_prefix}.__index(#{idx_name})"
+          idx_steps = steps + [{ kind: :element_access }]
+
+          debug "   [index] #{idx_name} → #{idx_fqn}"
+          debug "           axes: [#{axes.join(', ')}]"
+          debug "           steps: #{idx_steps.map do |s|
+            case s[:kind]
+            when :property_access then ".#{s[:key]}"
+            when :element_access  then '[]'
+            when :array_loop      then "loop(#{s[:axis]})"
+            end
+          end.join(' ')}"
+
+          @plans << Core::Analyzer::Plans::InputPlan.new(
+            source_path: [],               # synthetic (not an actual declared field path)
+            axes: axes,
+            dtype: :integer,               # indices are integers
+            key_policy: @defaults[:key_policy],
+            missing_policy: @defaults[:on_missing],
+            navigation_steps: idx_steps,
+            path_fqn: idx_fqn
+          )
+
+          @index_table[idx_name] = { axes: axes, fqn: idx_fqn }
+        end
+      end
+    end
+  end
+end

data/lib/kumi/core/explain.rb

@@ -122,10 +122,11 @@ module Kumi
         end
 
         def chain_of_same_op?(expr, fn) = expr.args.any? { |a| a.is_a?(Kumi::Syntax::CallExpression) && a.fn_name == fn }
+
         def flatten_chain(expr, fn)
-          expr.args.flat_map { |a|
+          expr.args.flat_map do |a|
             a.is_a?(Kumi::Syntax::CallExpression) && a.fn_name == fn ? flatten_chain(a, fn) : [a]
-          }
+          end
         end
 
         def op_symbol(fn)
@@ -153,6 +154,7 @@ module Kumi
 
         def eval_arg_for_display(arg)
           return format_expression(arg, indent_context: 0, nested: true) if literalish?(arg)
+
           val = evaluate(arg)
           if arg.is_a?(Kumi::Syntax::DeclarationReference)
             "(#{format_expression(arg, indent_context: 0, nested: true)} = #{format_value(val)})"
@@ -165,16 +167,21 @@ module Kumi
           case v
           when Float, Integer then format_number(v)
           when String         then "\"#{v}\""
-          when Array          then v.length <= 4 ? "[#{v.map { |x| format_value(x) }.join(', ')}]" :
-                                                  "[#{v.take(4).map { |x| format_value(x) }.join(', ')}, …]"
+          when Array          then if v.length <= 4
+                                     "[#{v.map { |x| format_value(x) }.join(', ')}]"
+                                   else
+                                     "[#{v.take(4).map { |x| format_value(x) }.join(', ')}, …]"
+                                   end
           else v.to_s
           end
         end
 
         def format_number(n)
           return n.to_s unless n.is_a?(Numeric)
-          i = (n.is_a?(Integer) || n == n.to_i) ? n.to_i : nil
+
+          i = n.is_a?(Integer) || n == n.to_i ? n.to_i : nil
           return n.to_s unless i
+
           i.abs >= 1000 ? i.to_s.reverse.gsub(/(\d{3})(?=\d)/, '\\1 ').reverse : i.to_s
         end
 
@@ -222,12 +229,12 @@ module Kumi
         def dig_path(h, path)
           node = h
           path.each do |seg|
-            if node.is_a?(Hash)
-              node = fetch_indifferent(node, seg)
-            else
-              # if arrays are in path, interpret seg as index when Integer-like
-              node = seg.is_a?(Integer) ? node[seg] : nil
-            end
+            node = if node.is_a?(Hash)
+                     fetch_indifferent(node, seg)
+                   else
+                     # if arrays are in path, interpret seg as index when Integer-like
+                     seg.is_a?(Integer) ? node[seg] : nil
+                   end
           end
           node
         end

data/lib/kumi/core/functions/loader.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "yaml"
+require_relative "model"
+require_relative "type_rules"
+
+module Kumi
+  module Core
+    module Functions
+      module Loader
+        module_function
+
+        def load_minimal_functions
+          functions_root = File.expand_path("../../../../data/functions", __dir__)
+          yaml_files = Dir.glob(File.join(functions_root, "**/*.yaml"))
+
+          function_specs = {}
+          yaml_files.each do |file|
+            specs = load_file(file)
+            specs.each { |spec| function_specs[spec.id] = spec }
+          end
+
+          function_specs
+        end
+
+        def load_file(file_path)
+          doc = YAML.safe_load_file(file_path, permitted_classes: [], aliases: false) || {}
+          (doc["functions"] || []).map { |fn_hash| build_function_spec(fn_hash) }
+        end
+
+        def build_function_spec(fn_hash)
+          function_id = fn_hash.fetch("id")
+          function_kind = fn_hash.fetch("kind").to_sym
+          parameter_names = (fn_hash["params"] || []).map { |p| p["name"].to_sym }
+          dtype_rule_fn = TypeRules.compile_dtype_rule(fn_hash.fetch("dtype"), parameter_names)
+
+          FunctionSpec.new(
+            id: function_id,
+            kind: function_kind,
+            parameter_names: parameter_names,
+            dtype_rule: dtype_rule_fn
+          )
+        end
+      end
+    end
+  end
+end

data/lib/kumi/core/functions/model.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# Minimal function specification for NAST dimensional analysis
+FunctionSpec = Struct.new(
+  :id,              # "core.add"
+  :kind,            # :elementwise, :reduce, :constructor
+  :parameter_names, # [:left_operand, :right_operand]
+  :dtype_rule,      # "promote(left_operand,right_operand)" or proc
+  keyword_init: true
+)

data/lib/kumi/core/functions/type_rules.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module Functions
+      module TypeRules
+        module_function
+
+        def normalize_type_symbol(type_symbol)
+          Kumi::Core::Types.normalize(type_symbol)
+        end
+
+        # Minimal type promotion for NAST analysis
+        def promote_types(*input_types)
+          normalized = input_types.flatten.compact.uniq
+          return :float if normalized.include?(:float)
+          return :integer if normalized.include?(:integer)
+
+          normalized.first
+        end
+
+        def common_type(element_types)
+          promote_types(element_types)
+        end
+
+        def unify_types(type1, type2)
+          return type1 if type1 == type2
+
+          promote_types(type1, type2) # Fall back to promotion for now
+        end
+
+        def same_type_as(reference_type_symbol)
+          normalize_type_symbol(reference_type_symbol)
+        rescue StandardError
+          # binding.pry
+          # raise
+          # TODO CHECK HOW HANDLE THIS
+        end
+
+        def array_type(element_type)
+          :"array<#{element_type}>"
+        end
+
+        def tuple_type(*element_types)
+          :"tuple<#{element_types.join(', ')}>"
+        end
+
+        # Parses a collection type symbol to find its element type.
+        def element_type_of(collection_type)
+          str_type = collection_type.to_s
+          if (m = /\Aarray<(.+)>\z/.match(str_type))
+            return m[1].to_sym
+          end
+
+          if (m = /\Atuple<(.+)>\z/.match(str_type))
+            # The "element type" of a tuple is the common promoted type of its members.
+            # e.g., tuple<integer, float> -> float
+            member_types = m[1].split(",").map { |s| s.strip.to_sym }
+            return promote_types(member_types)
+          end
+
+          normalize_type_symbol(str_type)
+        end
+
+        # Compile dtype rule string into callable
+        def compile_dtype_rule(rule_string, _parameter_names)
+          rule = rule_string.to_s.strip
+
+          # --- NEW: Handle the "element_of" rule ---
+          if (m = /\Aelement_of\((.+)\)\z/.match(rule))
+            key = m[1].strip.to_sym
+            return ->(named) { element_type_of(named.fetch(key)) }
+          end
+
+          # Handle existing function-based rules
+          if (m = /\Apromote\((.+)\)\z/.match(rule))
+            keys = m[1].split(",").map { |s| s.strip.to_sym }
+            return ->(named) { promote_types(*keys.map { |k| named.fetch(k) }) }
+          end
+          if (m = /\Asame_as\((.+)\)\z/.match(rule))
+            key = m[1].strip.to_sym
+            return ->(named) { same_type_as(named.fetch(key)) }
+          end
+          if (m = /\Aunify\(([^,]+),\s*([^)]+)\)\z/.match(rule)) # TODO: - check if needed or is just the promote
+            k1 = m[1].strip.to_sym
+            k2 = m[2].strip.to_sym
+            return ->(named) { unify_types(named.fetch(k1), named.fetch(k2)) }
+          end
+          if (m = /\Acommon_type\((.+)\)\z/.match(rule))
+            param_name = m[1].strip.to_sym
+            return ->(named) { common_type(named.fetch(param_name)) }
+          end
+          if (m = /\Aarray\((.+)\)\z/.match(rule))
+            inner_rule = m[1].strip
+            inner_compiled = compile_dtype_rule(inner_rule, []) # param_names not needed here
+            return ->(named) { array_type(inner_compiled.call(named)) }
+          end
+          if (m = /\Atuple\(types\((.+)\)\)\z/.match(rule))
+            param_name = m[1].strip.to_sym
+            return ->(named) { tuple_type(*named.fetch(param_name)) }
+          end
+
+          ->(_) { normalize_type_symbol(rule.to_sym) }
+        end
+      end
+    end
+  end
+end

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

@@ -218,7 +218,7 @@ module Kumi
 
                   src = slots[op.args[0]]
                   result_scope = op.attrs[:result_scope]
-                  axis         = op.attrs[:axis]
+                  op.attrs[:axis]
 
                   if result_scope.empty?
                     # === GLOBAL REDUCE ===