kumi 0.0.4 → 0.0.6

data/lib/kumi/evaluation_wrapper.rb

@@ -3,20 +3,36 @@
 module Kumi
   EvaluationWrapper = Struct.new(:ctx) do
     def initialize(ctx)
-      @ctx = ctx
+      super
       @__schema_cache__ = {} # memoization cache for bindings
     end
 
     def [](key)
-      @ctx[key]
+      ctx[key]
+    end
+
+    def []=(key, value)
+      ctx[key] = value
     end
 
     def keys
-      @ctx.keys
+      ctx.keys
     end
 
     def key?(key)
-      @ctx.key?(key)
+      ctx.key?(key)
+    end
+
+    def clear
+      @__schema_cache__.clear
+    end
+
+    def clear_cache(*keys)
+      if keys.empty?
+        @__schema_cache__.clear
+      else
+        keys.each { |key| @__schema_cache__.delete(key) }
+      end
     end
   end
 end

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
@@ -56,27 +56,27 @@ module Kumi
 
       def format_call_expression(expr, indent_context: 0, nested: false)
         if pretty_printable?(expr.fn_name)
-          format_pretty_function(expr, expr.fn_name, indent_context, nested)
+          format_pretty_function(expr, expr.fn_name, indent_context, nested: nested)
         else
           format_generic_function(expr, indent_context)
         end
       end
 
-      def format_pretty_function(expr, fn_name, _indent_context, nested = false)
+      def format_pretty_function(expr, fn_name, _indent_context, nested: false)
         if needs_evaluation?(expr.args) && !nested
           # For top-level expressions, show the flattened symbolic form and evaluation
-          if is_chain_of_same_operator?(expr, fn_name)
+          if chain_of_same_operator?(expr, fn_name)
             # For chains like a + b + c, flatten to show all operands
             all_operands = flatten_operator_chain(expr, fn_name)
             symbolic_operands = all_operands.map { |op| format_expression(op, indent_context: 0, nested: true) }
             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
@@ -88,38 +88,38 @@ module Kumi
           else
             # Regular pretty formatting for non-chain expressions
             symbolic_args = expr.args.map { |arg| format_expression(arg, indent_context: 0, nested: true) }
-            symbolic_format = get_display_format(fn_name, symbolic_args)
+            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
                 end
               end
             end
-            evaluated_format = get_display_format(fn_name, evaluated_args)
+            evaluated_format = display_format(fn_name, evaluated_args)
 
           end
           "#{symbolic_format} = #{evaluated_format}"
         else
           # For nested expressions, just show the symbolic form without evaluation details
           args = expr.args.map { |arg| format_expression(arg, indent_context: 0, nested: true) }
-          get_display_format(fn_name, args)
+          display_format(fn_name, args)
         end
       end
 
-      def is_chain_of_same_operator?(expr, fn_name)
+      def chain_of_same_operator?(expr, fn_name)
         return false unless %i[add subtract multiply divide].include?(fn_name)
 
         # 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
@@ -152,7 +152,7 @@ module Kumi
         %i[add subtract multiply divide == != > < >= <= and or not].include?(fn_name)
       end
 
-      def get_display_format(fn_name, args)
+      def display_format(fn_name, args)
         case fn_name
         when :add then args.join(" + ")
         when :subtract then args.join(" - ")
@@ -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

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
@@ -84,6 +89,109 @@ module Kumi
             param_types: [Kumi::Types.array(:any)],
             return_type: Kumi::Types.array(:any),
             description: "Remove duplicate elements from collection"
+          ),
+
+          # Array transformation functions
+          flatten: FunctionBuilder::Entry.new(
+            fn: lambda(&:flatten),
+            arity: 1,
+            param_types: [Kumi::Types.array(:any)],
+            return_type: Kumi::Types.array(:any),
+            description: "Flatten nested arrays into a single array"
+          ),
+
+          # Mathematical transformation functions
+          map_multiply: FunctionBuilder::Entry.new(
+            fn: ->(collection, factor) { collection.map { |x| x * factor } },
+            arity: 2,
+            param_types: [Kumi::Types.array(:float), :float],
+            return_type: Kumi::Types.array(:float),
+            description: "Multiply each element by factor"
+          ),
+
+          map_add: FunctionBuilder::Entry.new(
+            fn: ->(collection, value) { collection.map { |x| x + value } },
+            arity: 2,
+            param_types: [Kumi::Types.array(:float), :float],
+            return_type: Kumi::Types.array(:float),
+            description: "Add value to each element"
+          ),
+
+          # Conditional transformation functions
+          map_conditional: FunctionBuilder::Entry.new(
+            fn: lambda { |collection, condition_value, true_value, false_value|
+              collection.map { |x| x == condition_value ? true_value : false_value }
+            },
+            arity: 4,
+            param_types: %i[array any any any],
+            return_type: :array,
+            description: "Transform elements based on condition: if element == condition_value then true_value else false_value"
+          ),
+
+          # Range/index functions for grid operations
+          build_array: FunctionBuilder::Entry.new(
+            fn: lambda { |size, &generator|
+              (0...size).map { |i| generator ? generator.call(i) : i }
+            },
+            arity: 1,
+            param_types: [:integer],
+            return_type: Kumi::Types.array(:any),
+            description: "Build array of given size with index values"
+          ),
+
+          range: FunctionBuilder::Entry.new(
+            fn: ->(start, finish) { (start...finish).to_a },
+            arity: 2,
+            param_types: %i[integer integer],
+            return_type: Kumi::Types.array(:integer),
+            description: "Generate range of integers from start to finish (exclusive)"
+          ),
+
+          # Array slicing and grouping for rendering
+          each_slice: FunctionBuilder::Entry.new(
+            fn: ->(array, size) { array.each_slice(size).to_a },
+            arity: 2,
+            param_types: %i[array integer],
+            return_type: Kumi::Types.array(:array),
+            description: "Group array elements into subarrays of given size"
+          ),
+
+          join: FunctionBuilder::Entry.new(
+            fn: lambda { |array, separator = ""|
+              array.map(&:to_s).join(separator.to_s)
+            },
+            arity: 2,
+            param_types: %i[array string],
+            return_type: :string,
+            description: "Join array elements into string with separator"
+          ),
+
+          # Transform each subarray to string and join the results
+          map_join_rows: FunctionBuilder::Entry.new(
+            fn: lambda { |array_of_arrays, row_separator = "", column_separator = "\n"|
+              array_of_arrays.map { |row| row.join(row_separator.to_s) }.join(column_separator.to_s)
+            },
+            arity: 3,
+            param_types: [Kumi::Types.array(:array), :string, :string],
+            return_type: :string,
+            description: "Join 2D array into string with row and column separators"
+          ),
+
+          # Higher-order collection functions (limited to common patterns)
+          map_with_index: FunctionBuilder::Entry.new(
+            fn: ->(collection) { collection.map.with_index.to_a },
+            arity: 1,
+            param_types: [Kumi::Types.array(:any)],
+            return_type: Kumi::Types.array(:any),
+            description: "Map collection elements to [element, index] pairs"
+          ),
+
+          indices: FunctionBuilder::Entry.new(
+            fn: ->(collection) { (0...collection.size).to_a },
+            arity: 1,
+            param_types: [Kumi::Types.array(:any)],
+            return_type: Kumi::Types.array(:integer),
+            description: "Generate array of indices for the collection"
           )
         }
       end

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

data/lib/kumi/parser/declaration_reference_proxy.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Parser
+    # DSL proxy for declaration references (traits and values)
+    # Handles references to declared items and field access on them
+    class DeclarationReferenceProxy
+      include Syntax
+      
+      # Use shared operator methods
+      extend Sugar::ProxyRefinement
+
+      def initialize(name, context)
+        @name = name
+        @context = context
+      end
+
+      # Convert to DeclarationReference AST node
+      def to_ast_node
+        Kumi::Syntax::DeclarationReference.new(@name, loc: @context.current_location)
+      end
+
+      private
+
+      def method_missing(method_name, *args, &block)
+        # All operators are handled by ProxyRefinement methods
+        # Field access should use input.field.subfield syntax, not bare identifiers
+        super
+      end
+
+      def respond_to_missing?(_method_name, _include_private = false)
+        true
+      end
+    end
+  end
+end

data/lib/kumi/parser/dsl_cascade_builder.rb

@@ -20,7 +20,8 @@ module Kumi
         trait_names = args[0..-2]
         expr = args.last
 
-        condition = create_function_call(:all?, trait_names, on_loc)
+        trait_bindings = convert_trait_names_to_bindings(trait_names, on_loc)
+        condition = create_fn(:all?, trait_bindings)
         result = ensure_syntax(expr)
         add_case(condition, result)
       end
@@ -32,7 +33,8 @@ module Kumi
         trait_names = args[0..-2]
         expr = args.last
 
-        condition = create_function_call(:any?, trait_names, on_loc)
+        trait_bindings = convert_trait_names_to_bindings(trait_names, on_loc)
+        condition = create_fn(:any?, trait_bindings)
         result = ensure_syntax(expr)
         add_case(condition, result)
       end
@@ -44,7 +46,8 @@ module Kumi
         trait_names = args[0..-2]
         expr = args.last
 
-        condition = create_function_call(:none?, trait_names, on_loc)
+        trait_bindings = convert_trait_names_to_bindings(trait_names, on_loc)
+        condition = create_fn(:none?, trait_bindings)
         result = ensure_syntax(expr)
         add_case(condition, result)
       end
@@ -80,13 +83,21 @@ module Kumi
         raise_error("cascade '#{method_name}' requires an expression as the last argument", location)
       end
 
-      def create_function_call(function_name, trait_names, location)
-        trait_bindings = trait_names.map { |name| create_binding(name, location) }
-        create_fn(function_name, trait_bindings)
+      def convert_trait_names_to_bindings(trait_names, location)
+        trait_names.map do |name|
+          case name
+          when Symbol
+            create_binding(name, location)
+          when DeclarationReference
+            name  # Already a binding from method_missing
+          else
+            raise_error("trait reference must be a symbol or bare identifier, got #{name.class}", location)
+          end
+        end
       end
 
       def add_case(condition, result)
-        @cases << WhenCaseExpression.new(condition, result)
+        @cases << Kumi::Syntax::CaseExpression.new(condition, result)
       end
 
       def ref(name)
@@ -118,7 +129,7 @@ module Kumi
       end
 
       def create_binding(name, location)
-        Binding.new(name, loc: location)
+        Kumi::Syntax::DeclarationReference.new(name, loc: location)
       end
     end
   end