kumi 0.0.25 → 0.0.26

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

@@ -5,38 +5,44 @@ require "date"
 module Kumi
   module Core
     module Types
-      # Normalizes different type inputs to canonical forms
+      # Normalizes different type inputs to canonical Type objects
       class Normalizer
-        # Type normalization - convert various inputs to canonical type symbols
+        # Type normalization - convert various inputs to Type objects
         def self.normalize(type_input)
           case type_input
+          when Type
+            # Already a Type object, return as-is
+            type_input
           when Symbol
-            return type_input if Validator.valid_type?(type_input)
-
-            raise ArgumentError, "Invalid type symbol: #{type_input}"
+            if Validator.valid_kind?(type_input)
+              Kumi::Core::Types.scalar(type_input)
+            else
+              raise ArgumentError, "Invalid type symbol: #{type_input}"
+            end
           when String
             symbol_type = type_input.to_sym
-            return symbol_type if Validator.valid_type?(symbol_type)
-
-            raise ArgumentError, "Invalid type string: #{type_input}"
+            if Validator.valid_kind?(symbol_type)
+              Kumi::Core::Types.scalar(symbol_type)
+            else
+              raise ArgumentError, "Invalid type string: #{type_input}"
+            end
           when Hash
-            return type_input if Validator.valid_type?(type_input)
-
-            raise ArgumentError, "Invalid type hash: #{type_input}"
+            raise ArgumentError, "Hash-based types no longer supported, use Type objects instead"
           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"
-            else
-              raise ArgumentError, "Unsupported class type: #{type_input}"
-            end
+            kind = 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 scalar(:hash) for hash type"
+                   else
+                     raise ArgumentError, "Unsupported class type: #{type_input}"
+                   end
+            Kumi::Core::Types.scalar(kind)
           else
             case type_input
             when Integer, Float, Numeric
@@ -46,28 +52,6 @@ module Kumi
             end
           end
         end
-
-        # Legacy compatibility - coerce old constants to symbols
-        def self.coerce(type_input)
-          # Handle legacy constant usage
-          return type_input if type_input.is_a?(Symbol) && Validator.valid_type?(type_input)
-
-          # Handle legacy constant objects
-          case type_input
-          when STRING then :string
-          when INT then :integer
-          when FLOAT, NUMERIC then :float # Both FLOAT and NUMERIC map to :float
-          when BOOL then :boolean
-          when ANY then :any
-          when SYMBOL then :symbol
-          when REGEXP then :regexp
-          when TIME then :time
-          when DATE then :date
-          when DATETIME then :datetime
-          else
-            normalize(type_input)
-          end
-        end
       end
     end
   end

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

@@ -7,36 +7,25 @@ module Kumi
       class Validator
         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 !type.is_a?(Hash) && VALID_TYPES.include?(type.to_s.to_sym)
-
-          return true if array_type?(type)
-          return true if hash_type?(type)
-
-          false
-        end
-
-        def self.array_type?(type)
-          return true if type.is_a?(Hash) && type.keys == [:array] && valid_type?(type[:array])
+        # Validate scalar kinds (no :array or :hash)
+        VALID_KINDS = %i[string integer float boolean any symbol regexp time date datetime null].freeze
 
-          type = type.to_s
-          type.is_a?(String) && type.match?(/^array<(.+)>$/) && type.scan(/(\w+)/)[1..-1].flatten.all? { |t| valid_type?(t) }
+        def self.valid_kind?(kind)
+          VALID_KINDS.include?(kind)
         end
 
-        def item_types(type)
-        end
-
-        def self.hash_type?(type)
-          type.is_a?(Hash) &&
-            type.keys.sort == [:hash] &&
-            type[:hash].is_a?(Array) &&
-            type[:hash].size == 2 &&
-            valid_type?(type[:hash][0]) &&
-            valid_type?(type[:hash][1])
-        end
-
-        def self.primitive_type?(type)
-          VALID_TYPES.include?(type)
+        def self.valid_type?(type)
+          # Support Type objects
+          case type
+          when ScalarType
+            valid_kind?(type.kind)
+          when ArrayType, TupleType
+            true  # If constructed, it's valid
+          when Symbol
+            valid_kind?(type)
+          else
+            false
+          end
         end
       end
     end

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

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module Types
+      # Base class for all type objects
+      class Type
+        def scalar?
+          is_a?(ScalarType)
+        end
+
+        def array?
+          is_a?(ArrayType)
+        end
+
+        def tuple?
+          is_a?(TupleType)
+        end
+      end
+
+      # Represents scalar types: string, integer, float, boolean, hash
+      class ScalarType < Type
+        attr_reader :kind
+
+        def initialize(kind)
+          @kind = kind
+        end
+
+        def to_s
+          @kind.to_s
+        end
+
+        def inspect
+          "#<ScalarType:#{@kind}>"
+        end
+
+        def ==(other)
+          return false unless other.is_a?(ScalarType)
+          @kind == other.kind
+        end
+
+        def eql?(other)
+          self == other
+        end
+
+        def hash
+          [@kind].hash
+        end
+      end
+
+      # Represents array types with an element type
+      class ArrayType < Type
+        attr_reader :element_type
+
+        def initialize(element_type)
+          @element_type = element_type
+        end
+
+        def to_s
+          "array<#{@element_type}>"
+        end
+
+        def inspect
+          "#<ArrayType:#{to_s}>"
+        end
+
+        def ==(other)
+          return false unless other.is_a?(ArrayType)
+          @element_type == other.element_type
+        end
+
+        def eql?(other)
+          self == other
+        end
+
+        def hash
+          [@element_type].hash
+        end
+      end
+
+      # Represents tuple types with a list of element types
+      class TupleType < Type
+        attr_reader :element_types
+
+        def initialize(element_types)
+          @element_types = element_types
+        end
+
+        def to_s
+          "tuple<#{@element_types.join(', ')}>"
+        end
+
+        def inspect
+          "#<TupleType:#{to_s}>"
+        end
+
+        def ==(other)
+          return false unless other.is_a?(TupleType)
+          @element_types == other.element_types
+        end
+
+        def eql?(other)
+          self == other
+        end
+
+        def hash
+          @element_types.hash
+        end
+      end
+
+      # Namespace module for consistency with autoloader
+      module ValueObjects
+      end
+    end
+  end
+end

data/lib/kumi/core/types.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'types/value_objects'
+
 module Kumi
   module Core
     module Types
@@ -10,64 +12,70 @@ module Kumi
         tuple?(dtype) || array?(dtype)
       end
 
-      def self.tuple?(dtype) = dtype == :tuple || dtype.match?(/^tuple</)
-      def self.array?(dtype) = dtype == :array || dtype.match?(/^array</)
+      def self.tuple?(dtype)
+        dtype.is_a?(TupleType)
+      end
+
+      def self.array?(dtype)
+        dtype.is_a?(ArrayType)
+      end
 
       # Validation methods
       def self.valid_type?(type)
         Validator.valid_type?(type)
       end
 
-      # Type builders
-      def self.array(elem_type)
-        Builder.array(elem_type)
+      # Type value object constructors
+      def self.scalar(kind)
+        ScalarType.new(kind)
       end
 
-      def self.hash(key_type, val_type)
-        Builder.hash(key_type, val_type)
+      def self.array(element_type)
+        elem_obj = case element_type
+                   when Type
+                     element_type
+                   when :string, :integer, :float, :boolean, :hash, :any, :symbol, :regexp, :time, :date, :datetime, :null
+                     scalar(element_type)
+                   else
+                     raise ArgumentError,
+                           "array element must be Type object or scalar kind, got #{element_type.inspect}"
+                   end
+        ArrayType.new(elem_obj)
       end
 
-      # Normalization
-      def self.normalize(type_input)
-        Normalizer.normalize(type_input)
-      end
+      def self.tuple(element_types)
+        unless element_types.is_a?(Array)
+          raise ArgumentError, "tuple expects array of Type objects, got #{element_types.class}"
+        end
 
-      def self.coerce(type_input)
-        Normalizer.coerce(type_input)
+        # Convert any non-Type elements to Type objects
+        converted = element_types.map do |t|
+          case t
+          when Type
+            t
+          when :string, :integer, :float, :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}"
+          end
+        end
+
+        TupleType.new(converted)
       end
 
-      # Compatibility and unification
-      def self.compatible?(type1, type2)
-        Compatibility.compatible?(type1, type2)
+      def self.hash(key_type, val_type)
+        raise NotImplementedError, "Use scalar(:hash) instead - Kumi treats hash as scalar, not key/value pair"
       end
 
-      def self.unify(type1, type2)
-        Compatibility.unify(type1, type2)
+      # Normalization
+      def self.normalize(type_input)
+        Normalizer.normalize(type_input)
       end
 
       # Type inference
       def self.infer_from_value(value)
         Inference.infer_from_value(value)
       end
-
-      # Formatting
-      def self.type_to_s(type)
-        Formatter.type_to_s(type)
-      end
-
-      # Legacy compatibility constants (will be phased out)
-      # These should be replaced with symbols in user code over time
-      STRING = :string
-      INT = :integer # NOTE: using :integer instead of :int for clarity
-      FLOAT = :float
-      BOOL = :boolean
-      ANY = :any
-      SYMBOL = :symbol
-      REGEXP = :regexp
-      TIME = :time
-      DATE = :date
-      DATETIME = :datetime
-      NUMERIC = :float # Legacy: represents numeric compatibility
     end
   end
 end

data/lib/kumi/registry_v2/loader.rb

@@ -7,6 +7,96 @@ module Kumi
     module Loader
       module_function
 
+      # Build dtype rule from YAML specification (structured or legacy string format)
+      def build_dtype_rule_from_yaml(dtype_spec)
+        case dtype_spec
+        when String
+          # Legacy string format: "same_as(x)", "promote(a,b)", "integer", etc.
+          Kumi::Core::Functions::TypeRules.compile_dtype_rule(dtype_spec, [])
+        when Hash
+          # Structured format: { rule: 'same_as', param: 'x' }
+          build_dtype_rule_from_hash(dtype_spec)
+        else
+          raise "Invalid dtype specification: #{dtype_spec.inspect}"
+        end
+      end
+
+      # Build dtype rule from structured hash
+      def build_dtype_rule_from_hash(spec)
+        rule_type = spec.fetch('rule') { raise "dtype hash requires 'rule' key" }
+
+        case rule_type
+        when 'same_as'
+          param = spec.fetch('param') { raise "same_as rule requires 'param' key" }
+          Kumi::Core::Functions::TypeRules.build_same_as(param.to_sym)
+
+        when 'promote'
+          params = spec.fetch('params') { raise "promote rule requires 'params' key" }
+          param_syms = Array(params).map { |p| p.to_sym }
+          Kumi::Core::Functions::TypeRules.build_promote(*param_syms)
+
+        when 'element_of'
+          param = spec.fetch('param') { raise "element_of rule requires 'param' key" }
+          Kumi::Core::Functions::TypeRules.build_element_of(param.to_sym)
+
+        when 'unify'
+          param1 = spec.fetch('param1') { raise "unify rule requires 'param1' key" }
+          param2 = spec.fetch('param2') { raise "unify rule requires 'param2' key" }
+          Kumi::Core::Functions::TypeRules.build_unify(param1.to_sym, param2.to_sym)
+
+        when 'common_type'
+          param = spec.fetch('param') { raise "common_type rule requires 'param' key" }
+          Kumi::Core::Functions::TypeRules.build_common_type(param.to_sym)
+
+        when 'array'
+          if spec.key?('element_type')
+            element_type_spec = spec['element_type']
+            element_type = if element_type_spec.is_a?(Hash)
+                            # Nested structured format
+                            build_dtype_rule_from_hash(element_type_spec).call({})
+                          else
+                            # String or symbol
+                            element_type_spec.to_sym
+                          end
+            Kumi::Core::Functions::TypeRules.build_array(element_type)
+          elsif spec.key?('element_type_param')
+            element_type_param = spec['element_type_param'].to_sym
+            Kumi::Core::Functions::TypeRules.build_array(element_type_param)
+          else
+            raise "array rule requires either 'element_type' or 'element_type_param' key"
+          end
+
+        when 'tuple'
+          if spec.key?('element_types')
+            element_types_spec = spec['element_types']
+            element_types = Array(element_types_spec).map do |et|
+              if et.is_a?(Hash)
+                build_dtype_rule_from_hash(et).call({})
+              else
+                et.to_sym
+              end
+            end
+            Kumi::Core::Functions::TypeRules.build_tuple(*element_types)
+          elsif spec.key?('element_types_param')
+            element_types_param = spec['element_types_param'].to_sym
+            Kumi::Core::Functions::TypeRules.build_tuple(element_types_param)
+          else
+            raise "tuple rule requires either 'element_types' or 'element_types_param' key"
+          end
+
+        when 'scalar'
+          kind = spec.fetch('kind') { raise "scalar rule requires 'kind' key" }
+          kind_sym = kind.to_sym
+          unless Kumi::Core::Types::Validator.valid_kind?(kind_sym)
+            raise "scalar rule has unknown kind: #{kind}"
+          end
+          Kumi::Core::Functions::TypeRules.build_scalar(kind_sym)
+
+        else
+          raise "unknown dtype rule: #{rule_type}"
+        end
+      end
+
       # { "core.mul" => Function(id: "core.mul", kind: :elementwise, params: [...]) }
       def load_functions(dir, func_struct)
         files = Dir.glob(File.join(dir, "**", "*.y{a,}ml")).sort

data/lib/kumi/registry_v2.rb

@@ -22,7 +22,7 @@ module Kumi
       end
 
       def dtype_rule
-        @dtype_rule ||= Core::Functions::TypeRules.compile_dtype_rule(dtype, param_names)
+        @dtype_rule ||= Loader.build_dtype_rule_from_yaml(dtype)
       end
     end
 
@@ -32,6 +32,7 @@ module Kumi
       def initialize(functions_by_id, kernels_by_key)
         @functions = functions_by_id                         # "core.mul" => Function<...>
         @alias     = build_alias(@functions)                 # "count" => "agg.count"
+        @overload_resolver = Core::Functions::OverloadResolver.new(@functions)
         @kernels   = kernels_by_key                          # [fn_id, target_sym] => Kernel
         @by_id     = @kernels.values.to_h { |k| [k.id, k] }
       end
@@ -50,6 +51,12 @@ module Kumi
         end
       end
 
+      # Type-aware function resolution for overloads
+      # Returns the function_id that best matches the given argument types
+      def resolve_function_with_types(alias_or_id, arg_types)
+        @overload_resolver.resolve(alias_or_id, arg_types)
+      end
+
       def function_kind(id)        = function(id).kind
       def function_reduce?(id)     = function(id).reduce?
       def function_elementwise?(id) = function(id).elementwise?
@@ -104,6 +111,16 @@ module Kumi
           func.aliases.each { |al| acc[al] = func.id }
         end
       end
+
+      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
     end
 
     module_function

data/lib/kumi/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Kumi
-  VERSION = "0.0.25"
+  VERSION = "0.0.26"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kumi
 version: !ruby/object:Gem::Version
-  version: 0.0.25
+  version: 0.0.26
 platform: ruby
 authors:
 - André Muta
@@ -83,6 +83,7 @@ files:
 - docs/FORM_SCHEMA.md
 - docs/OUTPUT_SCHEMA.md
 - docs/SYNTAX.md
+- docs/UNSAT_DETECTION.md
 - examples/deep_schema_compilation_and_evaluation_benchmark.rb
 - examples/federal_tax_calculator_2024.rb
 - examples/game_of_life.rb
@@ -201,6 +202,21 @@ files:
 - golden/empty_and_null_inputs/expected/snast.txt
 - golden/empty_and_null_inputs/input.json
 - golden/empty_and_null_inputs/schema.kumi
+- golden/function_overload/expected/ast.txt
+- golden/function_overload/expected/input_plan.txt
+- golden/function_overload/expected/lir_00_unoptimized.txt
+- golden/function_overload/expected/lir_01_hoist_scalar_references.txt
+- golden/function_overload/expected/lir_02_inlined.txt
+- golden/function_overload/expected/lir_03_cse.txt
+- golden/function_overload/expected/lir_04_1_loop_fusion.txt
+- golden/function_overload/expected/lir_04_loop_invcm.txt
+- golden/function_overload/expected/lir_06_const_prop.txt
+- golden/function_overload/expected/nast.txt
+- golden/function_overload/expected/schema_javascript.mjs
+- golden/function_overload/expected/schema_ruby.rb
+- golden/function_overload/expected/snast.txt
+- golden/function_overload/input.json
+- golden/function_overload/schema.kumi
 - golden/game_of_life/expected.json
 - golden/game_of_life/expected/ast.txt
 - golden/game_of_life/expected/input_plan.txt
@@ -594,6 +610,7 @@ files:
 - lib/kumi/core/analyzer/passes/contract_checker_pass.rb
 - lib/kumi/core/analyzer/passes/declaration_validator.rb
 - lib/kumi/core/analyzer/passes/dependency_resolver.rb
+- lib/kumi/core/analyzer/passes/formal_constraint_propagator.rb
 - lib/kumi/core/analyzer/passes/input_access_planner_pass.rb
 - lib/kumi/core/analyzer/passes/input_collector.rb
 - lib/kumi/core/analyzer/passes/input_form_schema_pass.rb
@@ -629,8 +646,6 @@ files:
 - lib/kumi/core/analyzer/state_serde.rb
 - lib/kumi/core/analyzer/structs/access_plan.rb
 - lib/kumi/core/analyzer/structs/input_meta.rb
-- lib/kumi/core/analyzer/unsat_constant_evaluator.rb
-- lib/kumi/core/atom_unsat_solver.rb
 - lib/kumi/core/compiler/access_builder.rb
 - lib/kumi/core/compiler/access_codegen.rb
 - lib/kumi/core/compiler/access_emit/base.rb
@@ -645,7 +660,6 @@ files:
 - lib/kumi/core/compiler/accessors/materialize_accessor.rb
 - lib/kumi/core/compiler/accessors/ravel_accessor.rb
 - lib/kumi/core/compiler/accessors/read_accessor.rb
-- lib/kumi/core/constraint_relationship_solver.rb
 - lib/kumi/core/domain/enum_analyzer.rb
 - lib/kumi/core/domain/range_analyzer.rb
 - lib/kumi/core/domain/validator.rb
@@ -662,6 +676,8 @@ files:
 - lib/kumi/core/export/serializer.rb
 - lib/kumi/core/functions/function_spec.rb
 - lib/kumi/core/functions/loader.rb
+- lib/kumi/core/functions/overload_resolver.rb
+- lib/kumi/core/functions/type_error_reporter.rb
 - lib/kumi/core/functions/type_rules.rb
 - lib/kumi/core/input/type_matcher.rb
 - lib/kumi/core/input/validator.rb
@@ -705,12 +721,10 @@ files:
 - lib/kumi/core/ruby_parser/schema_builder.rb
 - lib/kumi/core/ruby_parser/sugar.rb
 - lib/kumi/core/types.rb
-- lib/kumi/core/types/builder.rb
-- lib/kumi/core/types/compatibility.rb
-- lib/kumi/core/types/formatter.rb
 - lib/kumi/core/types/inference.rb
 - lib/kumi/core/types/normalizer.rb
 - lib/kumi/core/types/validator.rb
+- lib/kumi/core/types/value_objects.rb
 - lib/kumi/dev.rb
 - lib/kumi/dev/codegen.rb
 - lib/kumi/dev/golden.rb

data/lib/kumi/core/analyzer/unsat_constant_evaluator.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-module Kumi
-  module Core
-    module Analyzer
-      class UnsatConstantEvaluator
-        include Syntax
-
-        def initialize(definitions)
-          @definitions = definitions
-          @memo = {}
-        end
-
-        OPERATORS = {
-          add: :+,
-          subtract: :-,
-          multiply: :*,
-          divide: :/
-        }.freeze
-
-        def evaluate(node, visited = Set.new)
-          return :unknown unless node
-          return @memo[node] if @memo.key?(node)
-          return node.value if node.is_a?(Literal)
-
-          result = case node
-                   when DeclarationReference then evaluate_binding(node, visited)
-                   when CallExpression then evaluate_call_expression(node, visited)
-                   else :unknown
-                   end
-
-          @memo[node] = result unless result == :unknown
-          result
-        end
-
-        private
-
-        def evaluate_binding(node, visited)
-          return :unknown if visited.include?(node.name)
-
-          visited << node.name
-          definition = @definitions[node.name]
-          return :unknown unless definition
-
-          evaluate(definition.expression, visited)
-        end
-
-        def evaluate_call_expression(node, visited)
-          return :unknown unless OPERATORS.key?(node.fn_name)
-
-          args = node.args.map { |arg| evaluate(arg, visited) }
-          return :unknown if args.any?(:unknown)
-
-          args.reduce(OPERATORS[node.fn_name])
-        end
-      end
-    end
-  end
-end