kumi 0.0.18 → 0.0.20

data/lib/kumi/core/lir.rb

@@ -0,0 +1,34 @@
+# lib/kumi/core/lir.rb
+module Kumi
+  module Core
+    module LIR
+      OPCODES = %i[
+        Constant
+        LoadInput
+        LoadDeclaration
+        LoadField
+        LoopStart
+        LoopEnd
+        KernelCall
+        Select
+        FoldCall
+        DeclareAccumulator
+        Accumulate
+        LoadAccumulator
+        MakeTuple
+        MakeObject
+        TupleGet
+        Yield
+      ].freeze
+
+      # Re-exports for stable API
+      Stamp       = Structs::Stamp
+      Literal     = Structs::Literal
+      Instruction = Structs::Instruction
+
+      # Re-export support classes
+      Ids   = Support::Ids
+      Error = Support::Error
+    end
+  end
+end

data/lib/kumi/core/nast.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module NAST
+      @next_id_mutex = Mutex.new
+      @next_id = 1
+
+      def self.next_id
+        @next_id_mutex.synchronize { @next_id += 1 }
+      end
+
+      def self.reset_id_counter!
+        @next_id_mutex.synchronize { @next_id = 1 }
+      end
+
+      Node = Struct.new(:id, :loc, :meta, keyword_init: true) do
+        def initialize(**args)
+          super
+          self.id ||= NAST.next_id
+          self.meta ||= {}
+        end
+
+        def accept(visitor)
+          visitor.visit_node(self)
+        end
+      end
+
+      class Const < Node
+        attr_reader :value
+
+        def initialize(value:, **k)
+          super(**k)
+          @value = value
+        end
+
+        def accept(visitor)
+          visitor.visit_const(self)
+        end
+      end
+
+      class InputRef < Node
+        attr_reader :path, :fqn, :key_chain, :element_terminal
+
+        def initialize(path:, fqn: nil, key_chain: [], element_terminal: false, **k)
+          super(**k)
+          @path = Array(path).map!(&:to_sym)
+          @fqn  = fqn || @path.join(".")
+          @key_chain = Array(key_chain).map!(&:to_sym)
+          @element_terminal = !!element_terminal
+        end
+
+        def path_fqn = @fqn
+
+        def accept(visitor)
+          visitor.visit_input_ref(self)
+        end
+      end
+
+      class Ref < Node
+        attr_reader :name
+
+        def initialize(name:, **k)
+          super(**k)
+          @name = name.to_sym
+        end
+
+        def accept(visitor)
+          visitor.visit_ref(self)
+        end
+      end
+
+      class IndexRef < Node
+        attr_reader :name, :input_fqn, :axes
+
+        def initialize(name:, input_fqn:, **k)
+          super(**k)
+          @name = name.to_sym
+          @input_fqn = input_fqn
+        end
+
+        def axes
+          meta[:stamp][:axes]
+        end
+
+        def accept(visitor) = visitor.respond_to?(:visit_index_ref) ? visitor.visit_index_ref(self) : super
+      end
+
+      class Call < Node
+        attr_reader :fn, :args, :opts
+
+        def initialize(fn:, args:, opts: {}, **k)
+          super(**k)
+          @fn = fn.to_sym
+          @args = args
+          @opts = opts
+        end
+
+        def accept(visitor)
+          visitor.visit_call(self)
+        end
+      end
+
+      class Tuple < Node
+        attr_reader :args
+
+        def initialize(args:, **k)
+          super(**k)
+          @args = args
+        end
+
+        def accept(visitor)
+          visitor.visit_tuple(self)
+        end
+      end
+
+      class Pair < Node
+        attr_reader :key, :value
+
+        def initialize(key:, value:, **k)
+          super(**k)
+          @key = key
+          @value = value
+        end
+
+        def accept(visitor)
+          visitor.visit_pair(self)
+        end
+      end
+
+      class Hash < Node
+        attr_reader :pairs
+
+        def initialize(pairs:, **k)
+          super(**k)
+          @pairs = pairs
+        end
+
+        def accept(visitor)
+          visitor.visit_hash(self)
+        end
+      end
+
+      # Control: ternary select (pure, eager)
+      class Select < Node
+        attr_reader :cond, :on_true, :on_false
+
+        def initialize(cond:, on_true:, on_false:, **k)
+          super(**k)
+          @cond = cond
+          @on_true = on_true
+          @on_false = on_false
+        end
+
+        def accept(visitor)
+          visitor.respond_to?(:visit_select) ? visitor.visit_select(self) : super
+        end
+      end
+
+      # Semantic reduction over explicit axes, with kernel id (e.g., :"agg.sum")
+      class Fold < Node
+        attr_reader :fn, :arg
+
+        def initialize(fn:, arg:, **k)
+          super(**k)
+          @fn = fn.to_sym
+          @arg = arg
+        end
+
+        def accept(visitor)
+          visitor.respond_to?(:visit_fold) ? visitor.visit_fold(self) : super
+        end
+      end
+
+      # Semantic reduction over explicit axes, with kernel id (e.g., :"agg.sum")
+      class Reduce < Node
+        attr_reader :fn, :over, :arg
+
+        def initialize(fn:, over:, arg:, **k)
+          super(**k)
+          @fn = fn.to_sym
+          @over  = Array(over).map!(&:to_sym)
+          @arg   = arg
+        end
+
+        def accept(visitor)
+          visitor.respond_to?(:visit_reduce) ? visitor.visit_reduce(self) : super
+        end
+      end
+
+      class Declaration < Node
+        attr_reader :name, :body
+
+        def initialize(name:, body:, **k)
+          super(**k)
+          @name = name.to_sym
+          @body = body
+        end
+
+        def accept(visitor)
+          visitor.visit_declaration(self)
+        end
+
+        def kind
+          meta[:kind]
+        end
+      end
+
+      Module = Struct.new(:decls, keyword_init: true) do
+        def accept(visitor)
+          visitor.visit_module(self)
+        end
+      end
+    end
+  end
+end

data/lib/kumi/core/ruby_parser/dsl.rb

@@ -4,9 +4,9 @@ module Kumi
   module Core
     module RubyParser
       module Dsl
-        def self.build_syntax_tree(&rule_block)
+        def self.build_syntax_tree(&)
           parser = Parser.new
-          parser.parse(&rule_block)
+          parser.parse(&)
         end
       end
     end

data/lib/kumi/core/ruby_parser/dsl_cascade_builder.rb

@@ -55,7 +55,7 @@ module Kumi
           add_case(create_literal(true), result)
         end
 
-        def method_missing(method_name, *args, &block)
+        def method_missing(method_name, *args, &)
           return super if !args.empty? || block_given?
 
           # Allow direct trait references in cascade conditions

data/lib/kumi/core/ruby_parser/expression_converter.rb

@@ -25,6 +25,8 @@ module Kumi
             create_literal(obj)
           when Array
             create_list(obj)
+          when Hash
+            create_hash(obj)
           when Syntax::Node
             obj
           else
@@ -81,6 +83,14 @@ module Kumi
           Kumi::Syntax::ArrayExpression.new(elements, loc: current_location)
         end
 
+        def create_hash(vhash)
+          pairs = vhash.map do |key, val|
+            [ensure_syntax(key), ensure_syntax(val)]
+          end
+
+          Kumi::Syntax::HashExpression.new(pairs, loc: current_location)
+        end
+
         def handle_custom_object(obj)
           if obj.respond_to?(:to_ast_node)
             obj.to_ast_node

data/lib/kumi/core/ruby_parser/input_builder.rb

@@ -23,9 +23,9 @@ module Kumi
           end
         end
 
-        def array(name_or_elem_type, **kwargs, &block)
+        def array(name_or_elem_type, **kwargs, &)
           if block_given?
-            create_array_field_with_block(name_or_elem_type, kwargs, &block)
+            create_array_field_with_block(name_or_elem_type, kwargs, &)
           elsif kwargs.any?
             create_array_field(name_or_elem_type, kwargs)
           else
@@ -33,9 +33,9 @@ module Kumi
           end
         end
 
-        def hash(name_or_key_type, val_type = nil, **kwargs, &block)
+        def hash(name_or_key_type, val_type = nil, **kwargs, &)
           if block_given?
-            create_hash_field_with_block(name_or_key_type, kwargs, &block)
+            create_hash_field_with_block(name_or_key_type, kwargs, &)
           elsif val_type.nil?
             create_hash_field(name_or_key_type, kwargs)
           else
@@ -98,32 +98,31 @@ module Kumi
           raise_syntax_error("Invalid types for hash `#{field_name}`: #{e.message}", location: @context.current_location)
         end
 
-        def create_array_field_with_block(field_name, options, &block)
+        def create_array_field_with_block(field_name, options, &)
           domain = options[:domain]
 
           # Collect children by creating a nested context
-          children, _, using_elements = collect_array_children(&block)
+          children, = collect_array_children(&)
 
           # Create the InputDeclaration with children and access_mode
-          access_mode = using_elements ? :element : :field
+          # access_mode = using_elements ? :element : :field
           @context.inputs << Kumi::Syntax::InputDeclaration.new(
             field_name,
             domain,
             :array,
             children,
-            access_mode,
             loc: @context.current_location
           )
         end
 
-        def collect_array_children(&block)
+        def collect_array_children(&)
           # Create a temporary nested context to collect children
           nested_inputs = []
           nested_context = NestedInput.new(nested_inputs, @context.current_location)
           nested_builder = InputBuilder.new(nested_context)
 
           # Execute the block in the nested context
-          nested_builder.instance_eval(&block)
+          nested_builder.instance_eval(&)
 
           # Determine element type based on what was declared
           elem_type = determine_element_type(nested_builder, nested_inputs)
@@ -151,17 +150,17 @@ module Kumi
         end
 
         # New method: element() declaration - always requires a name
-        def element(type_spec, name, &block)
+        def element(type_spec, name, &)
           @using_elements = true
           if block_given?
             # Named element with nested structure: element(:array, :rows) do ... end
             # These DO set @using_elements to enable element access mode for multi-dimensional arrays
             case type_spec
             when :array
-              create_array_field_with_block(name, {}, &block)
+              create_array_field_with_block(name, {}, &)
             when :field
               # Create nested object structure
-              create_object_element(name, &block)
+              create_object_element(name, &)
             else
               raise_syntax_error("element(#{type_spec.inspect}, #{name.inspect}) with block only supports :array or :field types",
                                  location: @context.current_location)
@@ -173,17 +172,17 @@ module Kumi
           end
         end
 
-        def create_object_element(name, &block)
+        def create_object_element(name, &)
           # Similar to create_array_field_with_block but for objects
-          children, = collect_array_children(&block)
+          children, = collect_array_children(&)
           @context.inputs << Kumi::Syntax::InputDeclaration.new(name, nil, :field, children, nil, loc: @context.current_location)
         end
 
-        def create_hash_field_with_block(field_name, options, &block)
+        def create_hash_field_with_block(field_name, options, &)
           domain = options[:domain]
 
           # Collect children by creating a nested context (reuse array logic)
-          children, = collect_array_children(&block)
+          children, = collect_array_children(&)
 
           # Create the InputDeclaration with children and :field access_mode for hash objects
           @context.inputs << Kumi::Syntax::InputDeclaration.new(

data/lib/kumi/core/ruby_parser/schema_builder.rb

@@ -8,12 +8,20 @@ module Kumi
         include Syntax
         include ErrorReporting
 
-        DSL_METHODS = %i[value trait input ref literal fn].freeze
+        DSL_METHODS = %i[value trait input ref literal fn select shift roll].freeze
 
         def initialize(context)
           @context = context
         end
 
+        def let(name = nil, expr = nil, &blk)
+          update_location
+          validate_value_args(name, expr, blk)
+
+          expression = blk ? build_cascade(&blk) : ensure_syntax(expr)
+          @context.values << Kumi::Syntax::ValueDeclaration.new(name, expression, inline: true, loc: @context.current_location)
+        end
+
         def value(name = nil, expr = nil, &blk)
           update_location
           validate_value_args(name, expr, blk)
@@ -28,7 +36,7 @@ module Kumi
           build_positional_trait(args)
         end
 
-        def input(&blk)
+        def input(&)
           return InputProxy.new(@context) unless block_given?
 
           raise_syntax_error("input block already defined", location: @context.current_location) if @context.input_block_defined?
@@ -36,7 +44,7 @@ module Kumi
 
           update_location
           input_builder = InputBuilder.new(@context)
-          input_builder.instance_eval(&blk)
+          input_builder.instance_eval(&)
         end
 
         def ref(name)
@@ -49,13 +57,31 @@ module Kumi
           Kumi::Syntax::Literal.new(value, loc: @context.current_location)
         end
 
-        def fn(fn_name, *args)
+        def fn(fn_name, *args, **kwargs)
           update_location
-          expr_args = args.map { |a| ensure_syntax(a) }
-          Kumi::Syntax::CallExpression.new(fn_name, expr_args, loc: @context.current_location)
+          expr_args = args.map { ensure_syntax(_1) }
+          Kumi::Syntax::CallExpression.new(fn_name, expr_args, kwargs, loc: @context.current_location)
+        end
+
+        def select(condition, value_when_true, value_when_false)
+          update_location
+          condition_expr = ensure_syntax(condition)
+          true_expr = ensure_syntax(value_when_true)
+          false_expr = ensure_syntax(value_when_false)
+          Kumi::Syntax::CallExpression.new(:__select__, [condition_expr, true_expr, false_expr], loc: @context.current_location)
+        end
+
+        def roll(*args, **kwargs)
+          args_expr = args.map { ensure_syntax(_1) }
+          Kumi::Syntax::CallExpression.new(:roll, args_expr, kwargs, loc: @context.current_location)
+        end
+
+        def shift(*args, **kwargs)
+          args_expr = args.map { ensure_syntax(_1) }
+          Kumi::Syntax::CallExpression.new(:roll, args_expr, kwargs, loc: @context.current_location)
         end
 
-        def method_missing(method_name, *args, &block)
+        def method_missing(method_name, *args, &)
           if args.empty? && !block_given?
             update_location
             # Create proxy for declaration references (traits/values)
@@ -154,15 +180,15 @@ module Kumi
             raise_syntax_error("expects a symbol for an operator, got #{operator.class}", location: @context.current_location)
           end
 
-          return if Kumi::Registry.operator?(operator)
+          return if Sugar::COMPARISON_OPS.include?(operator)
 
           raise_syntax_error("unsupported operator `#{operator}`", location: @context.current_location)
         end
 
-        def build_cascade(&blk)
+        def build_cascade(&)
           expression_converter = ExpressionConverter.new(@context)
           cascade_builder = DslCascadeBuilder.new(expression_converter, @context.current_location)
-          cascade_builder.instance_eval(&blk)
+          cascade_builder.instance_eval(&)
           Kumi::Syntax::CascadeExpression.new(cascade_builder.cases, loc: @context.current_location)
         end
 

data/lib/kumi/core/ruby_parser/sugar.rb

@@ -147,6 +147,70 @@ module Kumi
           end
         end
 
+        module HashRefinement
+          refine Hash do
+            # --- helpers ------------------------------------------------------
+            def any_syntax_expressions_in_hash?
+              any? { |k, v| Sugar.syntax_expression?(k) || Sugar.syntax_expression?(v) }
+            end
+
+            def to_syntax_hash
+              pairs = map { |k, v| Kumi::Syntax::Pair.new(Sugar.ensure_literal(k), Sugar.ensure_literal(v)) }
+              Kumi::Syntax::HashExpression.new(pairs)
+            end
+
+            # --- readers: no-arg methods -------------------------------------
+            %i[keys values size length empty?].each do |method_name|
+              define_method(method_name) do
+                if any_syntax_expressions_in_hash?
+                  Sugar.create_call_expression(method_name, [to_syntax_hash])
+                else
+                  super()
+                end
+              end
+            end
+
+            # --- membership ---------------------------------------------------
+            def include?(key)
+              if any_syntax_expressions_in_hash? || Sugar.syntax_expression?(key)
+                Sugar.create_call_expression(:has_key?, [to_syntax_hash, Sugar.ensure_literal(key)])
+              else
+                super
+              end
+            end
+            alias_method :key?, :include?
+            alias_method :has_key?, :include?
+
+            # --- element access -----------------------------------------------
+            def [](key)
+              if any_syntax_expressions_in_hash? || Sugar.syntax_expression?(key)
+                Sugar.create_call_expression(:get, [to_syntax_hash, Sugar.ensure_literal(key)])
+              else
+                super
+              end
+            end
+
+            def fetch(key, default = (missing = true
+                                      nil))
+              if any_syntax_expressions_in_hash? || Sugar.syntax_expression?(key) || (!missing && Sugar.syntax_expression?(default))
+                args = [to_syntax_hash, Sugar.ensure_literal(key)]
+                args << Sugar.ensure_literal(default) unless missing
+                Sugar.create_call_expression(:fetch, args)
+              else
+                missing ? super(key) : super
+              end
+            end
+
+            def dig(*path)
+              if any_syntax_expressions_in_hash? || path.any? { |k| Sugar.syntax_expression?(k) }
+                Sugar.create_call_expression(:dig, [to_syntax_hash, *path.map { |k| Sugar.ensure_literal(k) }])
+              else
+                super
+              end
+            end
+          end
+        end
+
         module ArrayRefinement
           refine Array do
             # Helper method to check if array contains any syntax expressions

data/lib/kumi/core/types/builder.rb

@@ -8,14 +8,14 @@ module Kumi
         def self.array(elem_type)
           raise ArgumentError, "Invalid array element type: #{elem_type}" unless Validator.valid_type?(elem_type)
 
-          { array: elem_type }
+          "array<#{elem_type}>"
         end
 
         def self.hash(key_type, val_type)
           raise ArgumentError, "Invalid hash key type: #{key_type}" unless Validator.valid_type?(key_type)
           raise ArgumentError, "Invalid hash value type: #{val_type}" unless Validator.valid_type?(val_type)
 
-          { hash: [key_type, val_type] }
+          :hash
         end
       end
     end

data/lib/kumi/core/types/normalizer.rb

@@ -26,9 +26,11 @@ module Kumi
           when Class
             # Handle Ruby class inputs
             case type_input.name
+            when "NilClass" then :null
             when "Integer" then :integer
             when "String" then :string
             when "Float" then :float
+            when "Symbol" then :symbol
             when "TrueClass", "FalseClass" then :boolean
             when "Array" then raise ArgumentError, "Use array(:type) helper for array types"
             when "Hash" then raise ArgumentError, "Use hash(:key_type, :value_type) helper for hash types"

data/lib/kumi/core/types/validator.rb

@@ -5,10 +5,11 @@ module Kumi
     module Types
       # Validates type definitions and structures
       class Validator
-        VALID_TYPES = %i[string integer float boolean any symbol regexp time date datetime array hash].freeze
+        VALID_TYPES = %i[string integer float boolean any symbol regexp time date datetime array hash null].freeze
 
         def self.valid_type?(type)
-          return true if VALID_TYPES.include?(type)
+          return true if !type.is_a?(Hash) && VALID_TYPES.include?(type.to_s.to_sym)
+
           return true if array_type?(type)
           return true if hash_type?(type)
 
@@ -16,7 +17,13 @@ module Kumi
         end
 
         def self.array_type?(type)
-          type.is_a?(Hash) && type.keys == [:array] && valid_type?(type[:array])
+          return true if type.is_a?(Hash) && type.keys == [:array] && valid_type?(type[:array])
+
+          type = type.to_s
+          type.is_a?(String) && type.match?(/^array<(.+)>$/) && type.scan(/(\w+)/)[1..-1].flatten.all? { |t| valid_type?(t) }
+        end
+
+        def item_types(type)
         end
 
         def self.hash_type?(type)

data/lib/kumi/core/types.rb

@@ -6,6 +6,13 @@ module Kumi
       # Re-export constants for compatibility
       VALID_TYPES = Validator::VALID_TYPES
 
+      def self.collection?(dtype)
+        tuple?(dtype) || array?(dtype)
+      end
+
+      def self.tuple?(dtype) = dtype == :tuple || dtype.match?(/^tuple</)
+      def self.array?(dtype) = dtype == :array || dtype.match?(/^array</)
+
       # Validation methods
       def self.valid_type?(type)
         Validator.valid_type?(type)