kumi 0.0.26 → 0.0.28

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

@@ -26,20 +26,37 @@ module Kumi
         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 it's already a full function ID, validate arity and type constraints
           if @functions.key?(s)
             validate_arity!(s, arg_types)
-            return s
+            fn = @functions[s]
+            score = match_score(fn.params, arg_types)
+            if score > 0
+              return s
+            else
+              # Type constraints failed
+              raise ResolutionError,
+                    "#{alias_or_id}(#{format_types(arg_types)}) - type mismatch"
+            end
           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
+          # Single overload - validate type constraints too
           if candidates.size == 1
-            validate_arity!(candidates.first, arg_types)
-            return candidates.first
+            fn_id = candidates.first
+            validate_arity!(fn_id, arg_types)
+            fn = @functions[fn_id]
+            score = match_score(fn.params, arg_types)
+            if score > 0
+              return fn_id
+            else
+              # Type constraints failed for the only overload
+              raise ResolutionError,
+                    "#{alias_or_id}(#{format_types(arg_types)}) - type mismatch"
+            end
           end
 
           # Multiple overloads - find best match by type constraints (prefer exact matches)
@@ -56,10 +73,8 @@ module Kumi
           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}"
+                "#{alias_or_id}(#{format_types(arg_types)}) - type mismatch"
         end
 
         # Get function object by ID (already resolved)
@@ -99,7 +114,7 @@ module Kumi
 
         def match_score(params, arg_types)
           # Returns match quality: higher is better
-          # 0 = no match, 1 = matches with unconstrained params, 2 = exact match
+          # 0 = no match, 1+ = match (1 for unconstrained params, higher for exact matches)
           return 0 unless params_match?(params, arg_types)
 
           # Count exact constraint matches (all arg_types are Type objects now)
@@ -108,11 +123,22 @@ module Kumi
             score_type_object_match(param_dtype, arg_type)
           end
 
-          exact_matches
+          # Return exact_matches + 1 so that: unconstrained=1, one exact=2, all exact=N+1
+          exact_matches + 1
         end
 
         def score_type_object_match(param_dtype, type_obj)
-          case param_dtype&.to_s
+          constraint = param_dtype&.to_s
+          return false unless constraint
+
+          # Check if it's a type category
+          if TypeCategories.category?(constraint)
+            return false unless type_obj.is_a?(Kumi::Core::Types::ScalarType)
+            return TypeCategories.includes?(constraint, type_obj.kind)
+          end
+
+          # Individual scalar type constraints
+          case constraint
           when "string"
             type_obj.is_a?(Kumi::Core::Types::ScalarType) && type_obj.kind == :string
           when "array"
@@ -131,6 +157,13 @@ module Kumi
         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)
 
+          # Check if it's a type category
+          if TypeCategories.category?(param_dtype_str)
+            return false unless arg_type.is_a?(Kumi::Core::Types::ScalarType)
+            return TypeCategories.includes?(param_dtype_str, arg_type.kind)
+          end
+
+          # Individual scalar type constraints
           case param_dtype_str
           when "string"
             arg_type.is_a?(Kumi::Core::Types::ScalarType) && arg_type.kind == :string
@@ -156,6 +189,19 @@ module Kumi
                 "function #{fn_id} expects #{fn.params.size} arguments, got #{arg_types.size}"
         end
 
+        private
+
+        def format_types(arg_types)
+          arg_types.map(&:to_s).join(", ")
+        end
+
+        def format_param_constraints(params)
+          params.map do |param|
+            dtype = param["dtype"]
+            dtype || "any"
+          end.join(", ")
+        end
+
         # Custom error for function resolution failures
         class ResolutionError < StandardError; end
       end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module Functions
+      # Type categories define reusable type constraints
+      # Instead of hardcoding type checks scattered throughout the codebase,
+      # we define categories once and reference them in function definitions
+      class TypeCategories
+        # Define type categories as unions of scalar kinds
+        CATEGORIES = {
+          numeric: [:integer, :float, :decimal],
+          comparable: [:integer, :float, :decimal, :string],
+          boolean: [:boolean],
+          stringable: [:string],
+          orderable: [:integer, :float, :decimal, :string]
+        }.freeze
+
+        def self.expand(dtype_constraint)
+          return dtype_constraint unless dtype_constraint.is_a?(String)
+
+          category = dtype_constraint.to_sym
+          CATEGORIES[category] || dtype_constraint
+        end
+
+        def self.includes?(dtype_constraint, kind)
+          kinds = expand(dtype_constraint)
+          return kinds.include?(kind) if kinds.is_a?(Array)
+
+          # Fall back to string comparison for uncategorized constraints
+          kinds == kind.to_s
+        end
+
+        def self.category?(name)
+          CATEGORIES.key?(name.to_sym)
+        end
+
+        def self.categories
+          CATEGORIES
+        end
+      end
+    end
+  end
+end

data/lib/kumi/core/input/type_matcher.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'bigdecimal'
+
 module Kumi
   module Core
     module Input
@@ -10,6 +12,8 @@ module Kumi
             value.is_a?(Integer)
           when :float
             value.is_a?(Float) || value.is_a?(Integer) # Allow integer for float
+          when :decimal
+            value.is_a?(BigDecimal) || value.is_a?(Float) || value.is_a?(Integer)
           when :string
             value.is_a?(String)
           when :boolean
@@ -36,7 +40,10 @@ module Kumi
           when Symbol then :symbol
           when Array then { array: :mixed }
           when Hash then { hash: %i[mixed mixed] }
-          else :unknown
+          else
+            return :decimal if value.is_a?(BigDecimal)
+
+            :unknown
           end
         end
 

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

@@ -16,7 +16,7 @@ module Kumi
           @context.inputs << Kumi::Syntax::InputDeclaration.new(name, domain, normalized_type, [], nil, loc: @context.current_location)
         end
 
-        %i[integer float string boolean any scalar].each do |type_name|
+        %i[integer float decimal string boolean any scalar].each do |type_name|
           define_method(type_name) do |name, type: nil, domain: nil|
             actual_type = type || (type_name == :scalar ? :any : type_name)
             @context.inputs << Kumi::Syntax::InputDeclaration.new(name, domain, actual_type, [], nil, loc: @context.current_location)
@@ -44,7 +44,7 @@ module Kumi
         end
 
         def method_missing(method_name, *_args)
-          allowed_methods = "'key', 'integer', 'float', 'string', 'boolean', 'any', 'scalar', 'array', 'hash', and 'element'"
+          allowed_methods = "'key', 'integer', 'float', 'decimal', 'string', 'boolean', 'any', 'scalar', 'array', 'hash', and 'element'"
           raise_syntax_error("Unknown method '#{method_name}' in input block. Only #{allowed_methods} are allowed.",
                              location: @context.current_location)
         end

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

@@ -35,6 +35,7 @@ module Kumi
                    when "Integer" then :integer
                    when "String" then :string
                    when "Float" then :float
+                   when "Decimal", "BigDecimal" then :decimal
                    when "Symbol" then :symbol
                    when "TrueClass", "FalseClass" then :boolean
                    when "Array" then raise ArgumentError, "Use array(:type) helper for array types"

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

@@ -5,10 +5,10 @@ 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 null].freeze
+        VALID_TYPES = %i[string integer float decimal boolean any symbol regexp time date datetime array hash null].freeze
 
         # Validate scalar kinds (no :array or :hash)
-        VALID_KINDS = %i[string integer float boolean any symbol regexp time date datetime null].freeze
+        VALID_KINDS = %i[string integer float decimal boolean any symbol regexp time date datetime null].freeze
 
         def self.valid_kind?(kind)
           VALID_KINDS.include?(kind)

data/lib/kumi/core/types.rb

@@ -34,7 +34,7 @@ module Kumi
         elem_obj = case element_type
                    when Type
                      element_type
-                   when :string, :integer, :float, :boolean, :hash, :any, :symbol, :regexp, :time, :date, :datetime, :null
+                   when :string, :integer, :float, :decimal, :boolean, :hash, :any, :symbol, :regexp, :time, :date, :datetime, :null
                      scalar(element_type)
                    else
                      raise ArgumentError,
@@ -53,7 +53,7 @@ module Kumi
           case t
           when Type
             t
-          when :string, :integer, :float, :boolean, :hash, :any, :symbol, :regexp, :time, :date, :datetime, :null
+          when :string, :integer, :float, :decimal, :boolean, :hash, :any, :symbol, :regexp, :time, :date, :datetime, :null
             scalar(t)
           else
             raise ArgumentError, "tuple element must be Type or scalar kind, got #{t.inspect}"

data/lib/kumi/dev/golden/reporter.rb

@@ -40,12 +40,14 @@ module Kumi
 
         def report_verify(results_by_schema)
           success = true
+          results_presented = false
 
           results_by_schema.each do |schema_name, results|
             failed_reprs = results.select { |r| !r.passed? }
 
             if failed_reprs.empty?
               puts "✓ #{schema_name}"
+              results_presented = true
             else
               success = false
               failed_msgs = failed_reprs.map do |r|
@@ -61,9 +63,16 @@ module Kumi
                 end
               end
               puts "✗ #{schema_name} (#{failed_msgs.join(', ')})"
+              results_presented = true
             end
           end
 
+          # If nothing was shown, report that results were empty
+          unless results_presented
+            puts "⚠ No test results to report - check that schema files exist"
+            success = false
+          end
+
           success
         end
 

data/lib/kumi/dev/golden/result.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'value_normalizer'
+
 module Kumi
   module Dev
     module Golden
@@ -60,7 +62,7 @@ module Kumi
         end
 
         def passed?
-          actual == expected
+          ValueNormalizer.values_equal?(actual, expected, language: language)
         end
 
         def failed?

data/lib/kumi/dev/golden/runtime_test.rb

@@ -2,6 +2,8 @@
 
 require "json"
 require "open3"
+require "bigdecimal"
+require_relative "value_normalizer"
 
 module Kumi
   module Dev
@@ -64,6 +66,9 @@ module Kumi
           code = File.read(code_file)
           input_data = JSON.parse(File.read(input_file))
 
+          # Convert decimal string inputs to BigDecimal
+          input_data = convert_decimal_strings(input_data)
+
           module_name = code.match(/module (Kumi::Compiled::\S+)/)[1]
           eval(code)
           module_const = Object.const_get(module_name)
@@ -72,6 +77,26 @@ module Kumi
           decl_names.to_h { |name| [name, instance[name.to_sym]] }
         end
 
+        private
+
+        def convert_decimal_strings(value)
+          case value
+          when Hash
+            value.transform_values { |v| convert_decimal_strings(v) }
+          when Array
+            value.map { |v| convert_decimal_strings(v) }
+          when String
+            # Convert decimal-like strings to BigDecimal
+            if value.match?(/\A-?\d+(\.\d+)?\z/)
+              BigDecimal(value)
+            else
+              value
+            end
+          else
+            value
+          end
+        end
+
         def execute_javascript(base_dir, decl_names)
           runner_path = File.expand_path("../support/kumi_runner.mjs", __dir__)
           raise "JS test runner not found at #{runner_path}" unless File.exist?(runner_path)

data/lib/kumi/dev/golden/suite.rb

@@ -16,25 +16,25 @@ module Kumi
         end
 
         def update(name = nil)
-          names = name ? [name] : schema_names
+          names = name ? (name.is_a?(Array) ? name : [name]) : schema_names
           results = update_schemas(names)
           Reporter.new.report_update(results)
         end
 
         def verify(name = nil)
-          names = name ? [name] : schema_names
+          names = name ? (name.is_a?(Array) ? name : [name]) : schema_names
           results = verify_schemas(names)
           Reporter.new.report_verify(results)
         end
 
         def diff(name = nil)
-          names = name ? [name] : schema_names
+          names = name ? (name.is_a?(Array) ? name : [name]) : schema_names
           results = diff_schemas(names)
           Reporter.new.report_diff(results)
         end
 
         def test(name = nil)
-          names = name ? [name] : schema_names
+          names = name ? (name.is_a?(Array) ? name : [name]) : schema_names
 
           update_schemas(names)
 

data/lib/kumi/dev/golden/value_normalizer.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'bigdecimal'
+
+module Kumi
+  module Dev
+    module Golden
+      # Normalizes values for test comparisons, handling decimal precision
+      class ValueNormalizer
+        def self.normalize(value, language: :ruby)
+          case value
+          when Hash
+            value.transform_values { |v| normalize(v, language: language) }
+          when Array
+            value.map { |v| normalize(v, language: language) }
+          when String
+            # Try to parse as decimal if it looks like one
+            if decimal_string?(value)
+              language == :ruby ? BigDecimal(value) : value
+            else
+              value
+            end
+          else
+            value
+          end
+        end
+
+        def self.values_equal?(actual, expected, language: :ruby)
+          norm_actual = normalize(actual, language: language)
+          norm_expected = normalize(expected, language: language)
+
+          compare_values(norm_actual, norm_expected, language: language)
+        end
+
+        private
+
+        def self.decimal_string?(str)
+          # Match decimal number strings like "10.50", "123", "-45.67"
+          str.match?(/\A-?\d+(\.\d+)?\z/)
+        end
+
+        def self.compare_values(actual, expected, language:)
+          # Handle decimal comparisons with tolerance for floating-point errors
+          case [actual, expected]
+          in [Array, Array]
+            actual.length == expected.length &&
+              actual.zip(expected).all? { |a, e| compare_values(a, e, language: language) }
+          in [Hash, Hash]
+            actual.keys == expected.keys &&
+              actual.all? { |k, v| compare_values(v, expected[k], language: language) }
+          in [BigDecimal, BigDecimal]
+            actual == expected
+          in [BigDecimal, (Integer | Float)]
+            BigDecimal(actual.to_s) == BigDecimal(expected.to_s)
+          in [(Integer | Float), BigDecimal]
+            BigDecimal(actual.to_s) == BigDecimal(expected.to_s)
+          in [(Integer | Float), String] | [String, (Integer | Float)]
+            # Compare number with decimal string (e.g., JavaScript number vs expected string)
+            actual_bd = BigDecimal(actual.to_s)
+            expected_bd = BigDecimal(expected.to_s)
+            # Allow small floating-point differences (within 1e-10)
+            (actual_bd - expected_bd).abs < BigDecimal("1e-10")
+          in [String, String]
+            # Both strings - try to parse as decimals and compare
+            begin
+              actual_bd = BigDecimal(actual)
+              expected_bd = BigDecimal(expected)
+              (actual_bd - expected_bd).abs < BigDecimal("1e-10")
+            rescue ArgumentError
+              # If not valid decimals, compare as strings
+              actual == expected
+            end
+          else
+            actual == expected
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kumi/dev/golden.rb

@@ -21,20 +21,27 @@ module Kumi
         suite.list
       end
 
-      def update!(name = nil)
-        suite.update(name)
+      def update!(*names)
+        names = [names].flatten.compact
+        names = nil if names.empty?
+        suite.update(names)
       end
 
-      def verify!(name = nil)
-        suite.verify(name)
+      def verify!(*names)
+        names = [names].flatten.compact
+        names = nil if names.empty?
+        suite.verify(names)
       end
 
-      def diff!(name = nil)
-        suite.diff(name)
+      def diff!(*names)
+        names = [names].flatten.compact
+        names = nil if names.empty?
+        suite.diff(names)
       end
 
-      def test_all_codegen!(name = nil)
-        names = name ? [name] : suite.send(:schema_names)
+      def test_all_codegen!(*names_arg)
+        names_arg = [names_arg].flatten.compact
+        names = names_arg.any? ? names_arg : suite.send(:schema_names)
 
         ruby_names = suite.send(:filter_testable_schemas, names, :ruby)
         ruby_results = ruby_names.map do |schema_name|
@@ -49,8 +56,9 @@ module Kumi
         Reporter.new.report_runtime_tests(ruby: ruby_results, javascript: js_results)
       end
 
-      def test_codegen!(name = nil)
-        names = name ? [name] : suite.send(:schema_names)
+      def test_codegen!(*names_arg)
+        names_arg = [names_arg].flatten.compact
+        names = names_arg.any? ? names_arg : suite.send(:schema_names)
         testable_names = suite.send(:filter_testable_schemas, names, :ruby)
         results = testable_names.map do |schema_name|
           RuntimeTest.new(schema_name, :ruby).run(suite.send(:schema_dir, schema_name))
@@ -58,8 +66,9 @@ module Kumi
         Reporter.new.report_runtime_tests(ruby: results)
       end
 
-      def test_js_codegen!(name = nil)
-        names = name ? [name] : suite.send(:schema_names)
+      def test_js_codegen!(*names_arg)
+        names_arg = [names_arg].flatten.compact
+        names = names_arg.any? ? names_arg : suite.send(:schema_names)
         testable_names = suite.send(:filter_testable_schemas, names, :javascript)
         results = testable_names.map do |schema_name|
           RuntimeTest.new(schema_name, :javascript).run(suite.send(:schema_dir, schema_name))

data/lib/kumi/doc_generator/formatters/json.rb

@@ -0,0 +1,39 @@
+require 'json'
+
+module Kumi
+  module DocGenerator
+    module Formatters
+      class Json
+        def initialize(docs)
+          @docs = docs
+        end
+
+        def format
+          enriched = @docs.each_with_object({}) do |(alias_name, entry), acc|
+            kernel_ids = extract_kernel_ids(entry['kernels'])
+            acc[alias_name] = {
+              'id' => entry['id'],
+              'kind' => entry['kind'],
+              'arity' => entry['arity'],
+              'params' => entry['params'],
+              'kernels' => kernel_ids,
+              'dtype' => entry['dtype'],
+              'aliases' => entry['aliases'],
+              'reduction_strategy' => entry['reduction_strategy']
+            }
+          end
+
+          JSON.pretty_generate(enriched)
+        end
+
+        private
+
+        def extract_kernel_ids(kernels)
+          kernels.each_with_object({}) do |(target, kernel), acc|
+            acc[target] = kernel.is_a?(Hash) ? kernel['id'] : kernel
+          end
+        end
+      end
+    end
+  end
+end