kumi 0.0.5 → 0.0.7

data/lib/kumi/compiler.rb

@@ -14,9 +14,26 @@ module Kumi
         compile_field(expr)
       end
 
+      def compile_element_field_reference(expr)
+        path = expr.path
+
+        lambda do |ctx|
+          # Start with the top-level collection from the context.
+          collection = ctx[path.first]
+
+          # Recursively map over the nested collections.
+          # The `dig_and_map` helper will handle any level of nesting.
+          dig_and_map(collection, path[1..])
+        end
+      end
+
       def compile_binding_node(expr)
-        fn = @bindings[expr.name].last
-        ->(ctx) { fn.call(ctx) }
+        name = expr.name
+        # Handle forward references in cycles by deferring binding lookup to runtime
+        lambda do |ctx|
+          fn = @bindings[name].last
+          fn.call(ctx)
+        end
       end
 
       def compile_list(expr)
@@ -27,28 +44,101 @@ module Kumi
       def compile_call(expr)
         fn_name = expr.fn_name
         arg_fns = expr.args.map { |a| compile_expr(a) }
-        ->(ctx) { invoke_function(fn_name, arg_fns, ctx, expr.loc) }
+
+        # Check if this is a vectorized operation
+        if vectorized_operation?(expr)
+          ->(ctx) { invoke_vectorized_function(fn_name, arg_fns, ctx, expr.loc) }
+        else
+          ->(ctx) { invoke_function(fn_name, arg_fns, ctx, expr.loc) }
+        end
       end
 
       def compile_cascade(expr)
-        pairs = expr.cases.map { |c| [compile_expr(c.condition), compile_expr(c.result)] }
-        lambda do |ctx|
-          pairs.each { |cond, res| return res.call(ctx) if cond.call(ctx) }
-          nil
+        # Check if current declaration is vectorized
+        broadcast_meta = @analysis.state[:broadcasts]
+        is_vectorized = @current_declaration && broadcast_meta&.dig(:vectorized_operations, @current_declaration)
+
+        # For vectorized cascades, we need to transform conditions that use all?
+        pairs = if is_vectorized
+                  expr.cases.map do |c|
+                    condition_fn = transform_vectorized_condition(c.condition)
+                    result_fn = compile_expr(c.result)
+                    [condition_fn, result_fn]
+                  end
+                else
+                  expr.cases.map { |c| [compile_expr(c.condition), compile_expr(c.result)] }
+                end
+
+        if is_vectorized
+          lambda do |ctx|
+            # This cascade can be vectorized - check if we actually need to at runtime
+            # Evaluate all conditions and results to check for arrays
+            cond_results = pairs.map { |cond, _res| cond.call(ctx) }
+            res_results = pairs.map { |_cond, res| res.call(ctx) }
+
+            # Check if any conditions or results are arrays (vectorized)
+            has_vectorized_data = (cond_results + res_results).any?(Array)
+
+            if has_vectorized_data
+              # Apply element-wise cascade evaluation
+              array_length = cond_results.find { |v| v.is_a?(Array) }&.length ||
+                             res_results.find { |v| v.is_a?(Array) }&.length || 1
+
+              (0...array_length).map do |i|
+                pairs.each_with_index do |(_cond, _res), pair_idx|
+                  cond_val = cond_results[pair_idx].is_a?(Array) ? cond_results[pair_idx][i] : cond_results[pair_idx]
+
+                  if cond_val
+                    res_val = res_results[pair_idx].is_a?(Array) ? res_results[pair_idx][i] : res_results[pair_idx]
+                    break res_val
+                  end
+                end || nil
+              end
+            else
+              # All data is scalar - use regular cascade evaluation
+              pairs.each_with_index do |(_cond, _res), pair_idx|
+                return res_results[pair_idx] if cond_results[pair_idx]
+              end
+              nil
+            end
+          end
+        else
+          lambda do |ctx|
+            pairs.each { |cond, res| return res.call(ctx) if cond.call(ctx) }
+            nil
+          end
         end
       end
+
+      def transform_vectorized_condition(condition_expr)
+        # If this is fn(:all?, [trait_ref]), extract the trait_ref for vectorized cascades
+        if condition_expr.is_a?(Kumi::Syntax::CallExpression) &&
+           condition_expr.fn_name == :all? &&
+           condition_expr.args.length == 1
+
+          arg = condition_expr.args.first
+          if arg.is_a?(Kumi::Syntax::ArrayExpression) && arg.elements.length == 1
+            trait_ref = arg.elements.first
+            return compile_expr(trait_ref)
+          end
+        end
+
+        # Otherwise compile normally
+        compile_expr(condition_expr)
+      end
     end
 
     include ExprCompilers
 
     # Map node classes to compiler methods
     DISPATCH = {
-      Syntax::TerminalExpressions::Literal => :compile_literal,
-      Syntax::TerminalExpressions::FieldRef => :compile_field_node,
-      Syntax::TerminalExpressions::Binding => :compile_binding_node,
-      Syntax::Expressions::ListExpression => :compile_list,
-      Syntax::Expressions::CallExpression => :compile_call,
-      Syntax::Expressions::CascadeExpression => :compile_cascade
+      Kumi::Syntax::Literal => :compile_literal,
+      Kumi::Syntax::InputReference => :compile_field_node,
+      Kumi::Syntax::InputElementReference => :compile_element_field_reference,
+      Kumi::Syntax::DeclarationReference => :compile_binding_node,
+      Kumi::Syntax::ArrayExpression => :compile_list,
+      Kumi::Syntax::CallExpression => :compile_call,
+      Kumi::Syntax::CascadeExpression => :compile_cascade
     }.freeze
 
     def self.compile(schema, analyzer:)
@@ -79,10 +169,30 @@ module Kumi
       @schema.traits.each     { |t| @index[t.name] = t }
     end
 
+    def dig_and_map(collection, path_segments)
+      return collection unless collection.is_a?(Array)
+
+      current_segment = path_segments.first
+      remaining_segments = path_segments[1..]
+
+      collection.map do |element|
+        value = element[current_segment]
+
+        # If there are more segments, recurse. Otherwise, return the value.
+        if remaining_segments.empty?
+          value
+        else
+          dig_and_map(value, remaining_segments)
+        end
+      end
+    end
+
     def compile_declaration(decl)
-      kind = decl.is_a?(Syntax::Declarations::Trait) ? :trait : :attr
-      fn   = compile_expr(decl.expression)
+      @current_declaration = decl.name
+      kind = decl.is_a?(Kumi::Syntax::TraitDeclaration) ? :trait : :attr
+      fn = compile_expr(decl.expression)
       @bindings[decl.name] = [kind, fn]
+      @current_declaration = nil
     end
 
     # Dispatch to the appropriate compile_* method
@@ -91,7 +201,6 @@ module Kumi
       send(method, expr)
     end
 
-    # Existing helpers unchanged
     def compile_field(node)
       name = node.name
       loc  = node.loc
@@ -103,6 +212,69 @@ module Kumi
       end
     end
 
+    def vectorized_operation?(expr)
+      # Check if this operation uses vectorized inputs
+      broadcast_meta = @analysis.state[:broadcasts]
+      return false unless broadcast_meta
+
+      # Reduction functions are NOT vectorized operations - they consume arrays
+      return false if FunctionRegistry.reducer?(expr.fn_name)
+
+      expr.args.any? do |arg|
+        case arg
+        when Kumi::Syntax::InputElementReference
+          broadcast_meta[:array_fields]&.key?(arg.path.first)
+        when Kumi::Syntax::DeclarationReference
+          broadcast_meta[:vectorized_operations]&.key?(arg.name)
+        else
+          false
+        end
+      end
+    end
+
+    def invoke_vectorized_function(name, arg_fns, ctx, loc)
+      # Evaluate arguments
+      values = arg_fns.map { |fn| fn.call(ctx) }
+
+      # Check if any argument is vectorized (array)
+      has_vectorized_args = values.any?(Array)
+
+      if has_vectorized_args
+        # Apply function with broadcasting to all vectorized arguments
+        vectorized_function_call(name, values)
+      else
+        # All arguments are scalars - regular function call
+        fn = FunctionRegistry.fetch(name)
+        fn.call(*values)
+      end
+    rescue StandardError => e
+      enhanced_message = "Error calling fn(:#{name}) at #{loc}: #{e.message}"
+      runtime_error = Errors::RuntimeError.new(enhanced_message)
+      runtime_error.set_backtrace(e.backtrace)
+      runtime_error.define_singleton_method(:cause) { e }
+      raise runtime_error
+    end
+
+    def vectorized_function_call(fn_name, values)
+      # Get the function from registry
+      fn = FunctionRegistry.fetch(fn_name)
+
+      # Find array dimensions for broadcasting
+      array_values = values.select { |v| v.is_a?(Array) }
+      return fn.call(*values) if array_values.empty?
+
+      # All arrays should have the same length (validation could be added)
+      array_length = array_values.first.size
+
+      # Broadcast and apply function element-wise
+      (0...array_length).map do |i|
+        element_args = values.map do |v|
+          v.is_a?(Array) ? v[i] : v # Broadcast scalars
+        end
+        fn.call(*element_args)
+      end
+    end
+
     def invoke_function(name, arg_fns, ctx, loc)
       fn = FunctionRegistry.fetch(name)
       values = arg_fns.map { |fn| fn.call(ctx) }

data/lib/kumi/constraint_relationship_solver.rb

@@ -98,12 +98,12 @@ module Kumi
     # @return [Relationship, nil] the relationship or nil if not extractable
     def extract_relationship(target, expression)
       case expression
-      when Kumi::Syntax::Expressions::CallExpression
+      when Kumi::Syntax::CallExpression
         extract_call_relationship(target, expression)
-      when Kumi::Syntax::TerminalExpressions::Binding
+      when Kumi::Syntax::DeclarationReference
         # Simple alias: target = other_variable
         Relationship.new(target, :identity, [expression.name])
-      when Kumi::Syntax::TerminalExpressions::FieldRef
+      when Kumi::Syntax::InputReference
         # Direct field reference: target = input.field
         # Create identity relationship so we can propagate constraints
         Relationship.new(target, :identity, [expression.name])
@@ -152,11 +152,11 @@ module Kumi
 
       args.map do |arg|
         case arg
-        when Kumi::Syntax::TerminalExpressions::Binding
+        when Kumi::Syntax::DeclarationReference
           arg.name
-        when Kumi::Syntax::TerminalExpressions::Literal
+        when Kumi::Syntax::Literal
           arg.value
-        when Kumi::Syntax::TerminalExpressions::FieldRef
+        when Kumi::Syntax::InputReference
           # Use the field name directly to match how atoms represent input fields
           arg.name
         else

data/lib/kumi/domain/validator.rb

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "range_analyzer"
-require_relative "enum_analyzer"
-require_relative "violation_formatter"
-
 module Kumi
   module Domain
     class Validator

data/lib/kumi/error_reporting.rb

@@ -54,7 +54,7 @@ module Kumi
 
     # Immediately raise a syntax error
     def raise_syntax_error(message, location: nil, context: {})
-      raise_localized_error(message, location: location, error_class: Errors::SyntaxError, type: :syntax, context: context)
+      raise_localized_error(message, location: location, error_class: Kumi::Errors::SyntaxError, type: :syntax, context: context)
     end
 
     # Immediately raise a type error

data/lib/kumi/explain.rb

@@ -37,17 +37,17 @@ module Kumi
 
       def format_expression(expr, indent_context: 0, nested: false)
         case expr
-        when Syntax::TerminalExpressions::FieldRef
+        when Kumi::Syntax::InputReference
           "input.#{expr.name}"
-        when Syntax::TerminalExpressions::Binding
+        when Kumi::Syntax::DeclarationReference
           expr.name.to_s
-        when Syntax::TerminalExpressions::Literal
+        when Kumi::Syntax::Literal
           format_value(expr.value)
-        when Syntax::Expressions::CallExpression
+        when Kumi::Syntax::CallExpression
           format_call_expression(expr, indent_context: indent_context, nested: nested)
-        when Syntax::Expressions::ListExpression
+        when Kumi::Syntax::ArrayExpression
           "[#{expr.elements.map { |e| format_expression(e, indent_context: indent_context, nested: nested) }.join(', ')}]"
-        when Syntax::Expressions::CascadeExpression
+        when Kumi::Syntax::CascadeExpression
           format_cascade_expression(expr, indent_context: indent_context)
         else
           expr.class.name.split("::").last
@@ -72,11 +72,11 @@ module Kumi
             symbolic_format = symbolic_operands.join(" #{get_operator_symbol(fn_name)} ")
 
             evaluated_operands = all_operands.map do |op|
-              if op.is_a?(Syntax::TerminalExpressions::Literal)
+              if op.is_a?(Kumi::Syntax::Literal)
                 format_expression(op, indent_context: 0, nested: true)
               else
                 arg_value = format_value(evaluate_expression(op))
-                if op.is_a?(Syntax::TerminalExpressions::Binding) && all_operands.length > 1
+                if op.is_a?(Kumi::Syntax::DeclarationReference) && all_operands.length > 1
                   "(#{format_expression(op, indent_context: 0, nested: true)} = #{arg_value})"
                 else
                   arg_value
@@ -91,12 +91,12 @@ module Kumi
             symbolic_format = display_format(fn_name, symbolic_args)
 
             evaluated_args = expr.args.map do |arg|
-              if arg.is_a?(Syntax::TerminalExpressions::Literal)
+              if arg.is_a?(Kumi::Syntax::Literal)
                 format_expression(arg, indent_context: 0, nested: true)
               else
                 arg_value = format_value(evaluate_expression(arg))
-                if arg.is_a?(Syntax::TerminalExpressions::Binding) &&
-                   expr.args.count { |a| !a.is_a?(Syntax::TerminalExpressions::Literal) } > 1
+                if arg.is_a?(Kumi::Syntax::DeclarationReference) &&
+                   expr.args.count { |a| !a.is_a?(Kumi::Syntax::Literal) } > 1
                   "(#{format_expression(arg, indent_context: 0, nested: true)} = #{arg_value})"
                 else
                   arg_value
@@ -119,7 +119,7 @@ module Kumi
 
         # Check if any argument is the same operator
         expr.args.any? do |arg|
-          arg.is_a?(Syntax::Expressions::CallExpression) && arg.fn_name == fn_name
+          arg.is_a?(Kumi::Syntax::CallExpression) && arg.fn_name == fn_name
         end
       end
 
@@ -127,7 +127,7 @@ module Kumi
         operands = []
 
         expr.args.each do |arg|
-          if arg.is_a?(Syntax::Expressions::CallExpression) && arg.fn_name == operator
+          if arg.is_a?(Kumi::Syntax::CallExpression) && arg.fn_name == operator
             # Recursively flatten nested operations of the same type
             operands.concat(flatten_operator_chain(arg, operator))
           else
@@ -176,8 +176,8 @@ module Kumi
           arg_desc = format_expression(arg, indent_context: indent_context)
 
           # For literals and literal lists, just show the value, no need for "100 = 100"
-          if arg.is_a?(Syntax::TerminalExpressions::Literal) ||
-             (arg.is_a?(Syntax::Expressions::ListExpression) && arg.elements.all?(Syntax::TerminalExpressions::Literal))
+          if arg.is_a?(Kumi::Syntax::Literal) ||
+             (arg.is_a?(Kumi::Syntax::ArrayExpression) && arg.elements.all?(Kumi::Syntax::Literal))
             arg_desc
           else
             arg_value = evaluate_expression(arg)
@@ -197,8 +197,8 @@ module Kumi
 
       def needs_evaluation?(args)
         args.any? do |arg|
-          !arg.is_a?(Syntax::TerminalExpressions::Literal) &&
-            !(arg.is_a?(Syntax::Expressions::ListExpression) && arg.elements.all?(Syntax::TerminalExpressions::Literal))
+          !arg.is_a?(Kumi::Syntax::Literal) &&
+            !(arg.is_a?(Kumi::Syntax::ArrayExpression) && arg.elements.all?(Kumi::Syntax::Literal))
         end
       end
 
@@ -252,11 +252,11 @@ module Kumi
 
       def evaluate_expression(expr)
         case expr
-        when Syntax::TerminalExpressions::Binding
+        when Kumi::Syntax::DeclarationReference
           @compiled_schema.evaluate_binding(expr.name, @inputs)
-        when Syntax::TerminalExpressions::FieldRef
+        when Kumi::Syntax::InputReference
           @inputs[expr.name]
-        when Syntax::TerminalExpressions::Literal
+        when Kumi::Syntax::Literal
           expr.value
         else
           # For complex expressions, compile and evaluate using existing compiler
@@ -274,6 +274,18 @@ module Kumi
 
       raise ArgumentError, "Schema not found or not compiled" unless syntax_tree && analyzer_result
 
+      metadata = analyzer_result.state
+
+      # Create a minimal analyzer result structure for compatibility
+      analyzer_result = OpenStruct.new(
+        definitions: metadata[:declarations] || {},
+        dependency_graph: metadata[:dependencies] || {},
+        leaf_map: metadata[:leaves] || {},
+        topo_order: metadata[:evaluation_order] || [],
+        decl_types: metadata[:inferred_types] || {},
+        state: metadata
+      )
+
       generator = ExplanationGenerator.new(syntax_tree, analyzer_result, inputs)
       generator.explain(target_name)
     end

data/lib/kumi/export/node_registry.rb

@@ -6,20 +6,34 @@ module Kumi
       # Maps AST classes to JSON type names
       SERIALIZATION_MAP = {
         "Kumi::Syntax::Root" => "root",
-        "Kumi::Syntax::Declarations::FieldDecl" => "field_declaration",
-        "Kumi::Syntax::Declarations::Attribute" => "attribute_declaration",
-        "Kumi::Syntax::Declarations::Trait" => "trait_declaration",
-        "Kumi::Syntax::Expressions::CallExpression" => "call_expression",
-        "Kumi::Syntax::TerminalExpressions::Literal" => "literal",
-        "Kumi::Syntax::TerminalExpressions::FieldRef" => "field_reference",
-        "Kumi::Syntax::TerminalExpressions::Binding" => "binding_reference",
-        "Kumi::Syntax::Expressions::ListExpression" => "list_expression",
-        "Kumi::Syntax::Expressions::CascadeExpression" => "cascade_expression",
-        "Kumi::Syntax::Expressions::WhenCaseExpression" => "when_case_expression"
+        "Kumi::Syntax::InputDeclaration" => "field_declaration",
+        "Kumi::Syntax::ValueDeclaration" => "attribute_declaration",
+        "Kumi::Syntax::TraitDeclaration" => "trait_declaration",
+        "Kumi::Syntax::CallExpression" => "call_expression",
+        "Kumi::Syntax::ArrayExpression" => "list_expression",
+        "Kumi::Syntax::HashExpression" => "hash_expression",
+        "Kumi::Syntax::CascadeExpression" => "cascade_expression",
+        "Kumi::Syntax::CaseExpression" => "when_case_expression",
+        "Kumi::Syntax::Literal" => "literal",
+        "Kumi::Syntax::InputReference" => "field_reference",
+        "Kumi::Syntax::DeclarationReference" => "binding_reference"
       }.freeze
 
-      # Maps JSON type names back to AST classes
-      DESERIALIZATION_MAP = SERIALIZATION_MAP.invert.freeze
+      # Maps JSON type names back to AST classes (using new canonical class names)
+      DESERIALIZATION_MAP = {
+        "root" => "Kumi::Syntax::Root",
+        "field_declaration" => "Kumi::Syntax::InputDeclaration",
+        "attribute_declaration" => "Kumi::Syntax::ValueDeclaration",
+        "trait_declaration" => "Kumi::Syntax::TraitDeclaration",
+        "call_expression" => "Kumi::Syntax::CallExpression",
+        "list_expression" => "Kumi::Syntax::ArrayExpression",
+        "hash_expression" => "Kumi::Syntax::HashExpression",
+        "cascade_expression" => "Kumi::Syntax::CascadeExpression",
+        "when_case_expression" => "Kumi::Syntax::CaseExpression",
+        "literal" => "Kumi::Syntax::Literal",
+        "field_reference" => "Kumi::Syntax::InputReference",
+        "binding_reference" => "Kumi::Syntax::DeclarationReference"
+      }.freeze
 
       def self.type_name_for(node)
         SERIALIZATION_MAP[node.class.name] or

data/lib/kumi/export/node_serializers.rb

@@ -66,7 +66,7 @@ module Kumi
         }
       end
 
-      # Binding Reference: critical for dependency resolution
+      # DeclarationReference Reference: critical for dependency resolution
       def serialize_binding_reference(node)
         {
           binding_name: node.name.to_s,

data/lib/kumi/function_registry/collection_functions.rb

@@ -6,10 +6,10 @@ module Kumi
     module CollectionFunctions
       def self.definitions
         {
-          # Collection queries
-          empty?: FunctionBuilder.collection_unary(:empty?, "Check if collection is empty", :empty?),
-          size: FunctionBuilder.collection_unary(:size, "Get collection size", :size, return_type: :integer),
-          length: FunctionBuilder.collection_unary(:length, "Get collection length", :length, return_type: :integer),
+          # Collection queries (these are reducers - they reduce arrays to scalars)
+          empty?: FunctionBuilder.collection_unary(:empty?, "Check if collection is empty", :empty?, reducer: true),
+          size: FunctionBuilder.collection_unary(:size, "Get collection size", :size, return_type: :integer, reducer: true),
+          length: FunctionBuilder.collection_unary(:length, "Get collection length", :length, return_type: :integer, reducer: true),
 
           # Element access
           first: FunctionBuilder::Entry.new(
@@ -17,7 +17,8 @@ module Kumi
             arity: 1,
             param_types: [Kumi::Types.array(:any)],
             return_type: :any,
-            description: "Get first element of collection"
+            description: "Get first element of collection",
+            reducer: true
           ),
 
           last: FunctionBuilder::Entry.new(
@@ -25,7 +26,8 @@ module Kumi
             arity: 1,
             param_types: [Kumi::Types.array(:any)],
             return_type: :any,
-            description: "Get last element of collection"
+            description: "Get last element of collection",
+            reducer: true
           ),
 
           # Mathematical operations on collections
@@ -34,7 +36,8 @@ module Kumi
             arity: 1,
             param_types: [Kumi::Types.array(:float)],
             return_type: :float,
-            description: "Sum all numeric elements in collection"
+            description: "Sum all numeric elements in collection",
+            reducer: true
           ),
 
           min: FunctionBuilder::Entry.new(
@@ -42,7 +45,8 @@ module Kumi
             arity: 1,
             param_types: [Kumi::Types.array(:float)],
             return_type: :float,
-            description: "Find minimum value in numeric collection"
+            description: "Find minimum value in numeric collection",
+            reducer: true
           ),
 
           max: FunctionBuilder::Entry.new(
@@ -50,7 +54,8 @@ module Kumi
             arity: 1,
             param_types: [Kumi::Types.array(:float)],
             return_type: :float,
-            description: "Find maximum value in numeric collection"
+            description: "Find maximum value in numeric collection",
+            reducer: true
           ),
 
           # Collection operations

data/lib/kumi/function_registry/function_builder.rb

@@ -4,7 +4,7 @@ module Kumi
   module FunctionRegistry
     # Utility class to reduce repetition in function definitions
     class FunctionBuilder
-      Entry = Struct.new(:fn, :arity, :param_types, :return_type, :description, :inverse, keyword_init: true)
+      Entry = Struct.new(:fn, :arity, :param_types, :return_type, :description, :inverse, :reducer, keyword_init: true)
 
       def self.comparison(_name, description, operation)
         Entry.new(
@@ -78,13 +78,14 @@ module Kumi
         )
       end
 
-      def self.collection_unary(_name, description, operation, return_type: :boolean)
+      def self.collection_unary(_name, description, operation, return_type: :boolean, reducer: false)
         Entry.new(
           fn: proc(&operation),
           arity: 1,
           param_types: [Kumi::Types.array(:any)],
           return_type: return_type,
-          description: description
+          description: description,
+          reducer: reducer
         )
       end
     end

data/lib/kumi/function_registry.rb

@@ -36,7 +36,7 @@ module Kumi
 
       # Register with custom metadata
       def register_with_metadata(name, fn_lambda, arity:, param_types: [:any], return_type: :any, description: nil,
-                                 inverse: nil)
+                                 inverse: nil, reducer: false)
         raise ArgumentError, "Function #{name.inspect} already registered" if @functions.key?(name)
 
         @functions[name] = Entry.new(
@@ -45,7 +45,8 @@ module Kumi
           param_types: param_types,
           return_type: return_type,
           description: description,
-          inverse: inverse
+          inverse: inverse,
+          reducer: reducer
         )
       end
 
@@ -91,6 +92,11 @@ module Kumi
         @functions.keys
       end
 
+      def reducer?(name)
+        entry = @functions.fetch(name) { return false }
+        entry.reducer || false
+      end
+
       # Alias for compatibility
       def all
         @functions.keys

data/lib/kumi/input/type_matcher.rb

@@ -15,6 +15,9 @@ module Kumi
           value.is_a?(TrueClass) || value.is_a?(FalseClass)
         when :symbol
           value.is_a?(Symbol)
+        when :array
+          # Simple :array type - just check if it's an Array
+          value.is_a?(Array)
         when :any
           true
         else

data/lib/kumi/input/validator.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "type_matcher"
-require_relative "violation_creator"
-
 module Kumi
   module Input
     class Validator