kumi 0.0.6 → 0.0.8

data/lib/kumi/types/builder.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module Kumi
-  module Types
-    # Builds complex type structures
-    class Builder
-      def self.array(elem_type)
-        raise ArgumentError, "Invalid array element type: #{elem_type}" unless Validator.valid_type?(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] }
-      end
-    end
-  end
-end

data/lib/kumi/types/compatibility.rb

@@ -1,94 +0,0 @@
-# frozen_string_literal: true
-
-module Kumi
-  module Types
-    # Handles type compatibility and unification
-    class Compatibility
-      # Check if two types are compatible
-      def self.compatible?(type1, type2)
-        # Any type is compatible with anything
-        return true if type1 == :any || type2 == :any
-
-        # Exact match
-        return true if type1 == type2
-
-        # Generic array compatibility: :array is compatible with any structured array
-        return true if (type1 == :array && Validator.array_type?(type2)) ||
-                       (type2 == :array && Validator.array_type?(type1))
-
-        # Numeric compatibility
-        return true if numeric_compatible?(type1, type2)
-
-        # Array compatibility
-        return array_compatible?(type1, type2) if array_types?(type1, type2)
-
-        # Hash compatibility
-        return hash_compatible?(type1, type2) if hash_types?(type1, type2)
-
-        false
-      end
-
-      # Find the most specific common type between two types
-      def self.unify(type1, type2)
-        return type1 if type1 == type2
-
-        # :any unifies to the other type (more specific)
-        return type2 if type1 == :any
-        return type1 if type2 == :any
-
-        # Generic array unification: structured array is more specific than :array
-        return type2 if type1 == :array && Validator.array_type?(type2)
-        return type1 if type2 == :array && Validator.array_type?(type1)
-
-        # Numeric unification
-        if numeric_compatible?(type1, type2)
-          return :integer if type1 == :integer && type2 == :integer
-
-          return :float # One or both are float
-        end
-
-        # Array unification
-        if array_types?(type1, type2)
-          elem1 = type1[:array]
-          elem2 = type2[:array]
-          unified_elem = unify(elem1, elem2)
-          return Kumi::Types.array(unified_elem)
-        end
-
-        # Hash unification
-        if hash_types?(type1, type2)
-          key1, val1 = type1[:hash]
-          key2, val2 = type2[:hash]
-          unified_key = unify(key1, key2)
-          unified_val = unify(val1, val2)
-          return Kumi::Types.hash(unified_key, unified_val)
-        end
-
-        # Fall back to :any for incompatible types
-        :any
-      end
-
-      def self.numeric_compatible?(type1, type2)
-        numeric_types = %i[integer float]
-        numeric_types.include?(type1) && numeric_types.include?(type2)
-      end
-
-      def self.array_types?(type1, type2)
-        Validator.array_type?(type1) && Validator.array_type?(type2)
-      end
-
-      def self.hash_types?(type1, type2)
-        Validator.hash_type?(type1) && Validator.hash_type?(type2)
-      end
-
-      def self.array_compatible?(type1, type2)
-        compatible?(type1[:array], type2[:array])
-      end
-
-      def self.hash_compatible?(type1, type2)
-        compatible?(type1[:hash][0], type2[:hash][0]) &&
-          compatible?(type1[:hash][1], type2[:hash][1])
-      end
-    end
-  end
-end

data/lib/kumi/types/formatter.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module Kumi
-  module Types
-    # Formats types for display and debugging
-    class Formatter
-      # Convert types to string representation
-      def self.type_to_s(type)
-        case type
-        when Hash
-          if type[:array]
-            "array(#{type_to_s(type[:array])})"
-          elsif type[:hash]
-            "hash(#{type_to_s(type[:hash][0])}, #{type_to_s(type[:hash][1])})"
-          else
-            type.to_s
-          end
-        else
-          type.to_s
-        end
-      end
-    end
-  end
-end

data/lib/kumi/types/inference.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-require "date"
-
-module Kumi
-  module Types
-    # Infers types from Ruby values
-    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 Array
-          return Kumi::Types.array(:any) if value.empty?
-
-          # Infer element type from first element (simple heuristic)
-          first_elem_type = infer_from_value(value.first)
-          Kumi::Types.array(first_elem_type)
-        when Hash
-          return Kumi::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::Types.hash(key_type, value_type)
-        else
-          :any
-        end
-      end
-    end
-  end
-end

data/lib/kumi/types/normalizer.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-require "date"
-
-module Kumi
-  module Types
-    # Normalizes different type inputs to canonical forms
-    class Normalizer
-      # Type normalization - convert various inputs to canonical type symbols
-      def self.normalize(type_input)
-        case type_input
-        when Symbol
-          return type_input if Validator.valid_type?(type_input)
-
-          raise ArgumentError, "Invalid type symbol: #{type_input}"
-        when String
-          symbol_type = type_input.to_sym
-          return symbol_type if Validator.valid_type?(symbol_type)
-
-          raise ArgumentError, "Invalid type string: #{type_input}"
-        when Hash
-          return type_input if Validator.valid_type?(type_input)
-
-          raise ArgumentError, "Invalid type hash: #{type_input}"
-        when Class
-          # Handle Ruby class inputs
-          case type_input.name
-          when "Integer" then :integer
-          when "String" then :string
-          when "Float" then :float
-          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
-        else
-          case type_input
-          when Integer, Float, Numeric
-            raise ArgumentError, "Type must be a symbol, got #{type_input} (#{type_input.class})"
-          else
-            raise ArgumentError, "Invalid type input: #{type_input} (#{type_input.class})"
-          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/types/validator.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-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].freeze
-
-      def self.valid_type?(type)
-        return true if VALID_TYPES.include?(type)
-        return true if array_type?(type)
-        return true if hash_type?(type)
-
-        false
-      end
-
-      def self.array_type?(type)
-        type.is_a?(Hash) && type.keys == [:array] && valid_type?(type[:array])
-      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)
-      end
-    end
-  end
-end

data/lib/kumi/types.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-module Kumi
-  module Types
-    # Re-export constants for compatibility
-    VALID_TYPES = Validator::VALID_TYPES
-
-    # Validation methods
-    def self.valid_type?(type)
-      Validator.valid_type?(type)
-    end
-
-    # Type builders
-    def self.array(elem_type)
-      Builder.array(elem_type)
-    end
-
-    def self.hash(key_type, val_type)
-      Builder.hash(key_type, val_type)
-    end
-
-    # Normalization
-    def self.normalize(type_input)
-      Normalizer.normalize(type_input)
-    end
-
-    def self.coerce(type_input)
-      Normalizer.coerce(type_input)
-    end
-
-    # Compatibility and unification
-    def self.compatible?(type1, type2)
-      Compatibility.compatible?(type1, type2)
-    end
-
-    def self.unify(type1, type2)
-      Compatibility.unify(type1, type2)
-    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

data/lib/kumi/vectorization_metadata.rb

@@ -1,108 +0,0 @@
-# frozen_string_literal: true
-
-module Kumi
-  # Metadata system for vectorization detection and handling
-  module VectorizationMetadata
-    # Tracks which declarations are arrays with children (vectorizable)
-    class ArrayDeclarationTracker
-      def initialize
-        @array_declarations = {}
-      end
-
-      def register_array(name, children)
-        @array_declarations[name] = children.map(&:name)
-      end
-
-      def array_declaration?(name)
-        @array_declarations.key?(name)
-      end
-
-      def array_children(name)
-        @array_declarations[name] || []
-      end
-
-      def all_arrays
-        @array_declarations.keys
-      end
-    end
-
-    # Detects vectorized operations in expressions
-    class VectorizationDetector
-      def initialize(array_tracker)
-        @array_tracker = array_tracker
-      end
-
-      # Check if an expression should be vectorized
-      def vectorized_expression?(expression)
-        case expression
-        when Kumi::Syntax::CallExpression
-          vectorized_call?(expression)
-        when Kumi::Syntax::InputElementReference
-          vectorized_element_reference?(expression)
-        else
-          false
-        end
-      end
-
-      # Check if a function call should be treated as a reducer
-      def reducer_function?(fn_name, args)
-        REDUCER_FUNCTIONS.include?(fn_name) && 
-          args.any? { |arg| vectorized_expression?(arg) }
-      end
-
-      private
-
-      REDUCER_FUNCTIONS = %i[sum min max size length first last].freeze
-
-      def vectorized_call?(call_expr)
-        # Arithmetic operations between array elements are vectorized
-        ARITHMETIC_OPERATIONS.include?(call_expr.fn_name) &&
-          call_expr.args.any? { |arg| vectorized_expression?(arg) }
-      end
-
-      def vectorized_element_reference?(elem_ref)
-        return false unless elem_ref.path.size >= 2
-        
-        array_name, _field_name = elem_ref.path
-        @array_tracker.array_declaration?(array_name)
-      end
-
-      ARITHMETIC_OPERATIONS = %i[add subtract multiply divide modulo power].freeze
-    end
-
-    # Metadata about how values should be computed
-    class ComputationMetadata
-      attr_reader :vectorized_values, :reducer_values, :scalar_values
-
-      def initialize
-        @vectorized_values = Set.new
-        @reducer_values = Set.new  
-        @scalar_values = Set.new
-      end
-
-      def mark_vectorized(name)
-        @vectorized_values.add(name)
-      end
-
-      def mark_reducer(name)
-        @reducer_values.add(name)
-      end
-
-      def mark_scalar(name)
-        @scalar_values.add(name)
-      end
-
-      def vectorized?(name)
-        @vectorized_values.include?(name)
-      end
-
-      def reducer?(name)
-        @reducer_values.include?(name)
-      end
-
-      def scalar?(name)
-        @scalar_values.include?(name)
-      end
-    end
-  end
-end