kumi 0.0.26 → 0.0.27

data/golden/reduction_broadcast/expected/schema_ruby.rb

@@ -1,5 +1,5 @@
 # Autogenerated by Kumi Codegen
-module Kumi::Compiled::KUMI_d4065d9b2c1fa95582e236ac4c79f6623745ec731b5961da26df7c2f9e2a9cb6
+module Kumi::Compiled::KUMI_6acd7e7a86400b5713bb861b265bd71ca0409744e38f91750bf81b1c8cc7b4f7
   def self.from(input_data = nil)
     instance = Object.new
     instance.extend(self)

data/golden/roll/expected/schema_ruby.rb

@@ -1,5 +1,5 @@
 # Autogenerated by Kumi Codegen
-module Kumi::Compiled::KUMI_ee08a4690485a37a0f18de249ead6563ffb9cf9625312459a6000d00cad9f29c
+module Kumi::Compiled::KUMI_bf0841514d27c68c3a5223b5c9e5625080c4342efd1141ccce1a07b41457e613
   def self.from(input_data = nil)
     instance = Object.new
     instance.extend(self)

data/golden/shift/expected/schema_ruby.rb

@@ -1,5 +1,5 @@
 # Autogenerated by Kumi Codegen
-module Kumi::Compiled::KUMI_c72cd3609d08e6946eb6c74183f400d8c0678040a863711e4b82a63da1b63319
+module Kumi::Compiled::KUMI_5e5c116e1acd27deccebcb9ab5ef133223c7005d86584465d3160f569d3c6a9b
   def self.from(input_data = nil)
     instance = Object.new
     instance.extend(self)

data/golden/shift_2d/expected/schema_ruby.rb

@@ -1,5 +1,5 @@
 # Autogenerated by Kumi Codegen
-module Kumi::Compiled::KUMI_1049f6474f9d41f05da4c2b6445c374c1eab40b0ff3089ecb80195a4550bceb8
+module Kumi::Compiled::KUMI_949d31a31d5b9027826a4d9e0ac0f4f7cf7ec0cf26a2a52a7da7dc7b6de71a1f
   def self.from(input_data = nil)
     instance = Object.new
     instance.extend(self)

data/golden/simple_math/expected/schema_ruby.rb

@@ -1,5 +1,5 @@
 # Autogenerated by Kumi Codegen
-module Kumi::Compiled::KUMI_52c858dd08717cf97edaff33a54004b4af6c064f32453eb33012e14cd18d48c2
+module Kumi::Compiled::KUMI_01c25ad1ae3550b0c23581f73407635ef18b1b5947933fe2edfdcbcef3253d37
   def self.from(input_data = nil)
     instance = Object.new
     instance.extend(self)

data/golden/streaming_basics/expected/schema_ruby.rb

@@ -1,5 +1,5 @@
 # Autogenerated by Kumi Codegen
-module Kumi::Compiled::KUMI_1d3b2fb0b1b00e7730f48d49c8c33acdea2ee603018ffacfc1349df73a8dd4ee
+module Kumi::Compiled::KUMI_e1cf5a39d9cce72668a167abe6fc8f84c427d0b38cc7759c0447e7822c722a43
   def self.from(input_data = nil)
     instance = Object.new
     instance.extend(self)

data/golden/tuples/expected/schema_ruby.rb

@@ -1,5 +1,5 @@
 # Autogenerated by Kumi Codegen
-module Kumi::Compiled::KUMI_2a2d7ca421c364fcc8994d8ea79ac793a5bfe18cd756cea122fc6ea42d8f6e9a
+module Kumi::Compiled::KUMI_b939a357fe30dacac4c3f90205c870e934bd818e640e50a63e39d2c387541a60
   def self.from(input_data = nil)
     instance = Object.new
     instance.extend(self)

data/golden/tuples_and_arrays/expected/schema_ruby.rb

@@ -1,5 +1,5 @@
 # Autogenerated by Kumi Codegen
-module Kumi::Compiled::KUMI_ada1b474771f2aaf5e63976adaf0402190d8744885036ff2a695e5bf8c93f65e
+module Kumi::Compiled::KUMI_b61e29419a3a15e4309079460b8a9fe1cb0cf4849c3f1d4264073c890a575c24
   def self.from(input_data = nil)
     instance = Object.new
     instance.extend(self)

data/golden/us_tax_2024/expected/schema_ruby.rb

@@ -1,5 +1,5 @@
 # Autogenerated by Kumi Codegen
-module Kumi::Compiled::KUMI_c9608112fc116466a01eeee25616ed8f4e011b48728f579b0bff1761f145e9ba
+module Kumi::Compiled::KUMI_6af882f233afb29fd899c6f83f4ad3d325f35951d32ae3139f886b34916fa881
   def self.from(input_data = nil)
     instance = Object.new
     instance.extend(self)

data/golden/with_constants/expected/schema_ruby.rb

@@ -1,5 +1,5 @@
 # Autogenerated by Kumi Codegen
-module Kumi::Compiled::KUMI_57ccd5ab1fc1187ce0abd20aa81d60fe4c33ce2438cccd991cd4fbd32e5a67e8
+module Kumi::Compiled::KUMI_67599b5d819e0f308bb60585f93878e89c60af8bea9e8006f92e07b1a479d336
   def self.from(input_data = nil)
     instance = Object.new
     instance.extend(self)

data/lib/kumi/configuration.rb

@@ -22,11 +22,17 @@ module Kumi
     # Useful for debugging the compiler itself.
     attr_accessor :force_recompile
 
+    # Decimal coercion behavior for inputs declared as `decimal` type.
+    # :automatic (default): Automatically coerce inputs to BigDecimal in Ruby
+    # :explicit: User must explicitly call to_decimal() in the schema
+    attr_accessor :decimal_coercion_mode
+
     def initialize
       # Set smart, environment-aware defaults.
       @cache_path = default_cache_path
       @compilation_mode = default_compilation_mode
       @force_recompile = false
+      @decimal_coercion_mode = :automatic
     end
 
     private

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

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

@@ -0,0 +1,175 @@
+module Kumi
+  module DocGenerator
+    module Formatters
+      class Markdown
+        def initialize(docs)
+          @docs = docs
+        end
+
+        def format
+          lines = [
+            "# Kumi Function Reference",
+            "",
+            "Auto-generated documentation for Kumi functions and their kernels.",
+            ""
+          ]
+
+          grouped = group_by_id(@docs)
+
+          grouped.sort.each do |id, aliases|
+            entry = @docs[aliases.first]
+            lines.concat(format_function(id, entry, aliases))
+          end
+
+          lines.join("\n")
+        end
+
+        private
+
+        def group_by_id(docs)
+          result = {}
+          docs.each do |alias_name, entry|
+            id = entry['id']
+            result[id] ||= []
+            result[id] << alias_name
+          end
+          result
+        end
+
+        def format_function(id, entry, aliases)
+          lines = [
+            "## `#{id}`",
+            ""
+          ]
+
+          if aliases.length > 1
+            lines << "**Aliases:** `#{aliases.sort.join('`, `')}`"
+            lines << ""
+          end
+
+          lines << "- **Arity:** #{entry['arity']}"
+
+          if entry['dtype']
+            dtype_str = format_dtype(entry['dtype'])
+            lines << "- **Type:** #{dtype_str}"
+          end
+
+          if is_reducer?(entry)
+            lines << "- **Behavior:** Reduces a dimension `[D] -> T`"
+          end
+          lines << ""
+
+          if entry['params'] && !entry['params'].empty?
+            lines << "### Parameters"
+            lines << ""
+            entry['params'].each do |param|
+              lines << "- `#{param['name']}`#{param['description'] ? ": #{param['description']}" : ""}"
+            end
+            lines << ""
+          end
+
+          if entry['kernels'] && !entry['kernels'].empty?
+            lines << "### Implementations"
+            lines << ""
+            entry['kernels'].each do |target, kernel|
+              lines.concat(format_kernel(target, kernel, entry['reduction_strategy']))
+            end
+          end
+
+          lines
+        end
+
+        def format_kernel(target, kernel, reduction_strategy = nil)
+          lines = []
+
+          if kernel.is_a?(Hash)
+            lines << "#### #{target.capitalize}"
+            lines << ""
+            lines << "`#{kernel['id']}`"
+            lines << ""
+
+            has_identity = kernel['identity'] && !kernel['identity'].empty?
+
+            if kernel['inline'] && has_identity
+              lines << "**Inline:** `#{escape_backticks(kernel['inline'])}` (`$0` = accumulator, `$1` = element)"
+              lines << ""
+            end
+
+            if kernel['impl']
+              lines << "**Implementation:**"
+              lines << ""
+              lines << "```ruby"
+              lines << format_impl(kernel['impl'])
+              lines << "```"
+              lines << ""
+            end
+
+            if kernel['fold_inline']
+              lines << "**Fold:** `#{escape_backticks(kernel['fold_inline'])}`"
+              lines << ""
+            end
+
+            if has_identity
+              lines << "**Identity:**"
+              kernel['identity'].each do |type, value|
+                lines << "- #{type}: `#{value}`"
+              end
+              lines << ""
+            elsif kernel['inline']
+              lines << "_Note: No identity value. First element initializes accumulator._"
+              lines << ""
+            end
+
+            # Show reduction strategy if available
+            if reduction_strategy
+              case reduction_strategy
+              when 'identity'
+                lines << "**Reduction:** Monoid operation with identity element"
+              when 'first_element'
+                lines << "**Reduction:** First element is initial value (no identity)"
+              else
+                lines << "**Reduction:** #{reduction_strategy}"
+              end
+              lines << ""
+            end
+          else
+            lines << "- **#{target}:** `#{kernel}`"
+          end
+
+          lines
+        end
+
+        def format_dtype(dtype)
+          return "any" if dtype.nil?
+
+          case dtype['rule']
+          when 'same_as'
+            "same as `#{dtype['param']}`"
+          when 'scalar'
+            dtype['kind'] || 'scalar'
+          when 'promote'
+            params = Array(dtype['params']).join('`, `')
+            "promoted from `#{params}`"
+          when 'element_of'
+            "element of `#{dtype['param']}`"
+          else
+            dtype['rule']
+          end
+        end
+
+        def format_impl(impl_str)
+          # Clean up multiline strings like "(a,b)\n  a + b"
+          impl_str.gsub('\n', "\n").strip
+        end
+
+        def escape_backticks(str)
+          str.gsub('`', '\`')
+        end
+
+        def is_reducer?(entry)
+          entry['kind'] == 'reduce'
+        end
+      end
+    end
+  end
+end