kumi 0.0.24 → 0.0.26

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

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module Functions
+      # OverloadResolver handles type-aware function overload resolution
+      # Given a function alias/id and argument types, finds the best matching function
+      #
+      # Responsibilities:
+      # - Track all function overloads per alias
+      # - Match argument types against parameter constraints
+      # - Provide clear error messages when resolution fails
+      class OverloadResolver
+        def initialize(functions_by_id)
+          @functions = functions_by_id                # "core.mul" => Function
+          @by_id = functions_by_id                    # Direct lookup
+          @alias_overloads = build_alias_overloads(functions_by_id)
+        end
+
+        # Resolve a function alias or ID to a specific function ID based on argument types
+        #
+        # @param alias_or_id [String, Symbol] Function alias or full function ID
+        # @param arg_types [Array<Symbol>] Inferred types of arguments
+        # @return [String] The resolved function_id
+        # @raise [ResolutionError] If function cannot be resolved
+        def resolve(alias_or_id, arg_types)
+          s = alias_or_id.to_s
+
+          # If it's already a full function ID, validate and return it
+          if @functions.key?(s)
+            validate_arity!(s, arg_types)
+            return s
+          end
+
+          # Get all candidate overloads for this alias
+          candidates = @alias_overloads[s]
+          raise ResolutionError, "unknown function #{alias_or_id}" if candidates.nil?
+
+          # Single overload - use it directly
+          if candidates.size == 1
+            validate_arity!(candidates.first, arg_types)
+            return candidates.first
+          end
+
+          # Multiple overloads - find best match by type constraints (prefer exact matches)
+          candidates_with_scores = candidates.map do |fn_id|
+            fn = @functions[fn_id]
+            score = match_score(fn.params, arg_types)
+            [fn_id, score]
+          end
+
+          best_match, score = candidates_with_scores.max_by { |_, s| s }
+
+          if score > 0
+            return best_match
+          end
+
+          # No match found - provide helpful error
+          available = candidates.map { |id| @functions[id].id }.join(", ")
+          raise ResolutionError,
+                "no overload of '#{alias_or_id}' matches argument types #{arg_types.inspect}. " \
+                "Available overloads: #{available}"
+        end
+
+        # Get function object by ID (already resolved)
+        def function(id)
+          @functions.fetch(id) do
+            raise ResolutionError, "unknown function #{id}"
+          end
+        end
+
+        # Check if a function exists
+        def exists?(id)
+          @functions.key?(id.to_s)
+        end
+
+        private
+
+        def build_alias_overloads(functions)
+          # Maps each alias to an array of all function_ids that have that alias
+          functions.values.each_with_object({}) do |func, acc|
+            func.aliases.each do |al|
+              acc[al] ||= []
+              acc[al] << func.id
+            end
+          end
+        end
+
+        def params_match?(params, arg_types)
+          # Check arity first
+          return false if params.size != arg_types.size
+
+          # Check each parameter constraint
+          params.zip(arg_types).all? do |param, arg_type|
+            param_dtype = param["dtype"]
+            param_dtype.nil? || type_compatible?(param_dtype, arg_type)
+          end
+        end
+
+        def match_score(params, arg_types)
+          # Returns match quality: higher is better
+          # 0 = no match, 1 = matches with unconstrained params, 2 = exact match
+          return 0 unless params_match?(params, arg_types)
+
+          # Count exact constraint matches (all arg_types are Type objects now)
+          exact_matches = params.zip(arg_types).count do |param, arg_type|
+            param_dtype = param["dtype"]
+            score_type_object_match(param_dtype, arg_type)
+          end
+
+          exact_matches
+        end
+
+        def score_type_object_match(param_dtype, type_obj)
+          case param_dtype&.to_s
+          when "string"
+            type_obj.is_a?(Kumi::Core::Types::ScalarType) && type_obj.kind == :string
+          when "array"
+            type_obj.is_a?(Kumi::Core::Types::ArrayType)
+          when "integer"
+            type_obj.is_a?(Kumi::Core::Types::ScalarType) && type_obj.kind == :integer
+          when "float"
+            type_obj.is_a?(Kumi::Core::Types::ScalarType) && type_obj.kind == :float
+          when "hash"
+            type_obj.is_a?(Kumi::Core::Types::ScalarType) && type_obj.kind == :hash
+          else
+            false
+          end
+        end
+
+        def type_compatible?(param_dtype_str, arg_type)
+          raise ArgumentError, "arg_type must be a Type object, got #{arg_type.inspect}" unless arg_type.is_a?(Kumi::Core::Types::Type)
+
+          case param_dtype_str
+          when "string"
+            arg_type.is_a?(Kumi::Core::Types::ScalarType) && arg_type.kind == :string
+          when "array"
+            arg_type.is_a?(Kumi::Core::Types::ArrayType)
+          when "integer"
+            arg_type.is_a?(Kumi::Core::Types::ScalarType) && arg_type.kind == :integer
+          when "float"
+            arg_type.is_a?(Kumi::Core::Types::ScalarType) && arg_type.kind == :float
+          when "hash"
+            arg_type.is_a?(Kumi::Core::Types::ScalarType) && arg_type.kind == :hash
+          else
+            # No constraint, any type matches
+            true
+          end
+        end
+
+        def validate_arity!(fn_id, arg_types)
+          fn = @functions[fn_id]
+          return if fn.params.size == arg_types.size
+
+          raise ResolutionError,
+                "function #{fn_id} expects #{fn.params.size} arguments, got #{arg_types.size}"
+        end
+
+        # Custom error for function resolution failures
+        class ResolutionError < StandardError; end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module Functions
+      # TypeErrorReporter provides typed error reporting for function resolution and type checking
+      # Ensures all type errors have proper location information for better diagnostics
+      module TypeErrorReporter
+        # Report function overload resolution failure with proper location
+        #
+        # @param errors [Array] Error accumulator
+        # @param alias_or_id [String, Symbol] Function alias or ID that couldn't be resolved
+        # @param arg_types [Array<Symbol>] Argument types that didn't match any overload
+        # @param available_overloads [Array<String>] Available function overload IDs
+        # @param location [Syntax::Location, nil] Where the error occurred
+        def self.report_overload_resolution_error(errors, alias_or_id, arg_types, available_overloads, location)
+          message = format_overload_error(alias_or_id, arg_types, available_overloads)
+
+          error = Core::ErrorReporter.create_error(
+            message,
+            location: location,
+            type: :type,
+            context: {
+              alias: alias_or_id.to_s,
+              arg_types: arg_types,
+              candidates: available_overloads
+            }
+          )
+
+          errors << error
+          error
+        end
+
+        # Report arity mismatch (wrong number of arguments)
+        #
+        # @param errors [Array] Error accumulator
+        # @param fn_id [String] Full function ID
+        # @param expected [Integer] Expected number of arguments
+        # @param actual [Integer] Actual number of arguments provided
+        # @param location [Syntax::Location, nil] Where the error occurred
+        def self.report_arity_mismatch(errors, fn_id, expected, actual, location)
+          message = "function '#{fn_id}' expects #{expected} argument(s), got #{actual}"
+
+          error = Core::ErrorReporter.create_error(
+            message,
+            location: location,
+            type: :type,
+            context: {
+              function: fn_id.to_s,
+              expected: expected,
+              actual: actual
+            }
+          )
+
+          errors << error
+          error
+        end
+
+        # Report type constraint violation (parameter type doesn't match argument type)
+        #
+        # @param errors [Array] Error accumulator
+        # @param fn_id [String] Full function ID
+        # @param param_name [String] Parameter name
+        # @param expected_type [String] Expected type constraint
+        # @param actual_type [Symbol] Actual argument type
+        # @param location [Syntax::Location, nil] Where the error occurred
+        def self.report_type_constraint_violation(errors, fn_id, param_name, expected_type, actual_type, location)
+          message = "function '#{fn_id}' parameter '#{param_name}' expects type #{expected_type.inspect}, " \
+                    "got #{actual_type.inspect}"
+
+          error = Core::ErrorReporter.create_error(
+            message,
+            location: location,
+            type: :type,
+            context: {
+              function: fn_id.to_s,
+              parameter: param_name.to_s,
+              expected_type: expected_type.to_s,
+              actual_type: actual_type.to_s
+            }
+          )
+
+          errors << error
+          error
+        end
+
+        # Report unknown function
+        #
+        # @param errors [Array] Error accumulator
+        # @param alias_or_id [String, Symbol] Function name/alias that doesn't exist
+        # @param location [Syntax::Location, nil] Where the error occurred
+        def self.report_unknown_function(errors, alias_or_id, location)
+          message = "unknown function '#{alias_or_id}'"
+
+          error = Core::ErrorReporter.create_error(
+            message,
+            location: location,
+            type: :semantic,
+            context: { function: alias_or_id.to_s }
+          )
+
+          errors << error
+          error
+        end
+
+        private
+
+        def self.format_overload_error(alias_or_id, arg_types, available_overloads)
+          arg_types_str = arg_types.map(&:inspect).join(", ")
+          available_str = available_overloads.map { |id| "'#{id}'" }.join(", ")
+
+          "no overload of '#{alias_or_id}' matches argument types (#{arg_types_str}). " \
+          "Available overloads: #{available_str}"
+        end
+      end
+    end
+  end
+end

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

@@ -6,17 +6,62 @@ module Kumi
       module TypeRules
         module_function
 
+        # Convert Type objects or symbols to Type objects
+        def to_type_object(type_input)
+          return type_input if type_input.is_a?(Kumi::Core::Types::Type)
+
+          # Convert symbol/string to Type object
+          case type_input
+          when :string
+            Kumi::Core::Types.scalar(:string)
+          when :integer
+            Kumi::Core::Types.scalar(:integer)
+          when :float
+            Kumi::Core::Types.scalar(:float)
+          when :boolean
+            Kumi::Core::Types.scalar(:boolean)
+          when :hash
+            Kumi::Core::Types.scalar(:hash)
+          when String
+            # Handle string type representations like "array<integer>" or "tuple<float, integer>"
+            parse_string_type(type_input)
+          else
+            # For any other type representation, normalize first
+            normalized = Kumi::Core::Types.normalize(type_input)
+            to_type_object(normalized)
+          end
+        end
+
+        def parse_string_type(str_type)
+          # Handle array types: "array<integer>"
+          if (m = /\Aarray<(.+)>\z/.match(str_type))
+            element_str = m[1]
+            element_type = to_type_object(element_str.to_sym)
+            return Kumi::Core::Types.array(element_type)
+          end
+
+          # Handle tuple types: "tuple<integer, float>"
+          if (m = /\Atuple<(.+)>\z/.match(str_type))
+            element_strs = m[1].split(",").map(&:strip)
+            element_types = element_strs.map { |s| to_type_object(s.to_sym) }
+            return Kumi::Core::Types.tuple(element_types)
+          end
+
+          # Try as symbol
+          to_type_object(str_type.to_sym)
+        end
+
         def normalize_type_symbol(type_symbol)
           Kumi::Core::Types.normalize(type_symbol)
         end
 
-        # Minimal type promotion for NAST analysis
+        # Type promotion for NAST analysis - returns Type objects
         def promote_types(*input_types)
-          normalized = input_types.flatten.compact.uniq
-          return :float if normalized.include?(:float)
-          return :integer if normalized.include?(:integer)
+          types = input_types.flatten.compact.uniq
+          return Kumi::Core::Types.scalar(:float) if types.any? { |t| float_type?(t) }
+          return Kumi::Core::Types.scalar(:integer) if types.any? { |t| integer_type?(t) }
 
-          normalized.first
+          to_type_object(types.first)
         end
 
         def common_type(element_types)
@@ -26,81 +71,156 @@ module Kumi
         def unify_types(type1, type2)
           return type1 if type1 == type2
 
-          promote_types(type1, type2) # Fall back to promotion for now
+          promote_types(type1, type2)
         end
 
-        def same_type_as(reference_type_symbol)
-          normalize_type_symbol(reference_type_symbol)
+        def same_type_as(reference_type)
+          to_type_object(reference_type)
         rescue StandardError
-          # binding.pry
-          # raise
-          # TODO CHECK HOW HANDLE THIS
+          to_type_object(reference_type)
         end
 
         def array_type(element_type)
-          :"array<#{element_type}>"
+          element_obj = to_type_object(element_type)
+          Kumi::Core::Types.array(element_obj)
         end
 
         def tuple_type(*element_types)
-          :"tuple<#{element_types.join(', ')}>"
+          element_objs = element_types.map { |t| to_type_object(t) }
+          Kumi::Core::Types.tuple(element_objs)
         end
 
-        # Parses a collection type symbol to find its element type.
+        # Extract element type from collection Type objects
         def element_type_of(collection_type)
-          str_type = collection_type.to_s
-          if (m = /\Aarray<(.+)>\z/.match(str_type))
-            return m[1].to_sym
+          type_obj = to_type_object(collection_type)
+
+          case type_obj
+          when Kumi::Core::Types::ArrayType
+            type_obj.element_type
+          when Kumi::Core::Types::TupleType
+            # Promote all element types to common type
+            promote_types(*type_obj.element_types)
+          else
+            type_obj
           end
+        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)
+        # --- Typed Rule Builders (Direct Type Construction) ---
+
+        # Build rule: return the type of a specific parameter
+        def build_same_as(param_name)
+          ->(named) { same_type_as(named.fetch(param_name)) }
+        end
+
+        # Build rule: promote types of multiple parameters
+        def build_promote(*param_names)
+          ->(named) { promote_types(*param_names.map { |k| named.fetch(k) }) }
+        end
+
+        # Build rule: extract element type from a collection parameter
+        def build_element_of(param_name)
+          ->(named) { element_type_of(named.fetch(param_name)) }
+        end
+
+        # Build rule: unify types of two parameters
+        def build_unify(param_name1, param_name2)
+          ->(named) { unify_types(named.fetch(param_name1), named.fetch(param_name2)) }
+        end
+
+        # Build rule: common type among array elements
+        def build_common_type(param_name)
+          ->(named) { common_type(named.fetch(param_name)) }
+        end
+
+        # Build rule: array of a specific element type
+        def build_array(element_type_or_param_name)
+          # Check if it's a known scalar kind or Type object
+          if element_type_or_param_name.is_a?(Kumi::Core::Types::Type)
+            # Type object - use directly
+            type_obj = element_type_or_param_name
+            ->(_) { Kumi::Core::Types.array(type_obj) }
+          elsif element_type_or_param_name.is_a?(Symbol) && Kumi::Core::Types::Validator.valid_kind?(element_type_or_param_name)
+            # Known scalar kind - create Type and wrap
+            type_obj = to_type_object(element_type_or_param_name)
+            ->(_) { Kumi::Core::Types.array(type_obj) }
+          else
+            # Treat as parameter name reference
+            ->(named) { array_type(named.fetch(element_type_or_param_name)) }
           end
+        end
+
+        # Build rule: tuple of specific element types
+        def build_tuple(*element_types_or_param_names)
+          # If single symbol and NOT a known scalar kind, treat as parameter reference
+          if element_types_or_param_names.size == 1 && element_types_or_param_names[0].is_a?(Symbol)
+            sym = element_types_or_param_names[0]
+            unless Kumi::Core::Types::Validator.valid_kind?(sym)
+              # Not a known kind - treat as parameter name (holds array of types)
+              return ->(named) { tuple_type(*named.fetch(sym)) }
+            end
+          end
+
+          # Interpret as explicit types
+          type_objs = element_types_or_param_names.map { |t| to_type_object(t) }
+          ->(_) { Kumi::Core::Types.tuple(type_objs) }
+        end
 
-          normalize_type_symbol(str_type)
+        # Build rule: constant scalar type
+        def build_scalar(kind)
+          ->(_) { to_type_object(kind) }
         end
 
-        # Compile dtype rule string into callable
+        # --- Compile dtype rule string into callable (backward compatible) ---
         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)) }
+            return build_element_of(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) }) }
+            return build_promote(*keys)
           end
+
           if (m = /\Asame_as\((.+)\)\z/.match(rule))
             key = m[1].strip.to_sym
-            return ->(named) { same_type_as(named.fetch(key)) }
+            return build_same_as(key)
           end
-          if (m = /\Aunify\(([^,]+),\s*([^)]+)\)\z/.match(rule)) # TODO: - check if needed or is just the promote
+
+          if (m = /\Aunify\(([^,]+),\s*([^)]+)\)\z/.match(rule))
             k1 = m[1].strip.to_sym
             k2 = m[2].strip.to_sym
-            return ->(named) { unify_types(named.fetch(k1), named.fetch(k2)) }
+            return build_unify(k1, k2)
           end
+
           if (m = /\Acommon_type\((.+)\)\z/.match(rule))
             param_name = m[1].strip.to_sym
-            return ->(named) { common_type(named.fetch(param_name)) }
+            return build_common_type(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
+            inner_compiled = compile_dtype_rule(inner_rule, [])
             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)) }
+            return build_tuple(param_name)
           end
 
-          ->(_) { normalize_type_symbol(rule.to_sym) }
+          # Constant scalar type
+          build_scalar(rule.to_sym)
+        end
+
+        def float_type?(t)
+          t.is_a?(Kumi::Core::Types::ScalarType) ? t.kind == :float : t == :float
+        end
+
+        def integer_type?(t)
+          t.is_a?(Kumi::Core::Types::ScalarType) ? t.kind == :integer : t == :integer
         end
       end
     end

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

@@ -9,31 +9,38 @@ module Kumi
       class Inference
         def self.infer_from_value(value)
           case value
-          when String then :string
-          when Integer then :integer
-          when Float then :float
-          when TrueClass, FalseClass then :boolean
-          when Symbol then :symbol
-          when Regexp then :regexp
-          when Time then :time
-          when DateTime then :datetime
-          when Date then :date
+          when String
+            Kumi::Core::Types.scalar(:string)
+          when Integer
+            Kumi::Core::Types.scalar(:integer)
+          when Float
+            Kumi::Core::Types.scalar(:float)
+          when TrueClass, FalseClass
+            Kumi::Core::Types.scalar(:boolean)
+          when Symbol
+            Kumi::Core::Types.scalar(:symbol)
+          when Regexp
+            Kumi::Core::Types.scalar(:regexp)
+          when Time
+            Kumi::Core::Types.scalar(:time)
+          when DateTime
+            Kumi::Core::Types.scalar(:datetime)
+          when Date
+            Kumi::Core::Types.scalar(:date)
           when Array
-            return Kumi::Core::Types.array(:any) if value.empty?
-
-            # Infer element type from first element (simple heuristic)
-            first_elem_type = infer_from_value(value.first)
-            Kumi::Core::Types.array(first_elem_type)
+            if value.empty?
+              Kumi::Core::Types.array(Kumi::Core::Types.scalar(:any))
+            else
+              # Infer element type from first element (simple heuristic)
+              elem_type = infer_from_value(value.first)
+              Kumi::Core::Types.array(elem_type)
+            end
           when Hash
-            return Kumi::Core::Types.hash(:any, :any) if value.empty?
-
-            # Infer key/value types from first pair (simple heuristic)
-            first_key, first_value = value.first
-            key_type = infer_from_value(first_key)
-            value_type = infer_from_value(first_value)
-            Kumi::Core::Types.hash(key_type, value_type)
+            # Kumi treats hash as scalar, not key/value pair type
+            # So we just return scalar(:hash) regardless of contents
+            Kumi::Core::Types.scalar(:hash)
           else
-            :any
+            Kumi::Core::Types.scalar(:any)
           end
         end
       end