kumi 0.0.7 → 0.0.9

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