kumi 0.0.12 → 0.0.14

data/lib/kumi/core/analyzer/passes/load_input_cse.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module Analyzer
+      module Passes
+        # Load Input Common Subexpression Elimination Pass
+        #
+        # Eliminates redundant load_input operations by reusing loads that
+        # were already stored by earlier declarations.
+        #
+        # OPTIMIZATION STRATEGY:
+        # - Cross-declaration load reuse: If a load_input with the same 
+        #   (plan_id, scope, is_scalar, has_idx) was already stored by an 
+        #   earlier declaration, rewrite later identical loads to ref the 
+        #   stored value instead of re-loading.
+        # - Only reuses producers that appear earlier in module order 
+        #   (no reordering/hoisting).
+        # - Safe because interpreter's outputs persist across declarations
+        #   and ref operations resolve previously stored values.
+        #
+        # REQUIREMENTS:
+        # - Must run after LowerToIR pass
+        # - IR module must be available in state
+        #
+        # DEBUG:
+        # - Set DEBUG_LOAD_CSE=1 to see optimization decisions
+        class LoadInputCSE < PassBase
+          def run(errors)
+            ir = get_state(:ir_module, required: true)
+            return state unless ir&.decls
+
+            debug = ENV["DEBUG_LOAD_CSE"]
+
+            # Map: key -> { name:, decl_index: }
+            producers = {}
+
+            puts "LOAD_CSE: Analyzing #{ir.decls.length} declarations" if debug
+
+            # First pass: find canonical producers (earliest decl that stores a given load)
+            ir.decls.each_with_index do |decl, di|
+              decl.ops.each_with_index do |op, oi|
+                next unless op.tag == :load_input
+                
+                key = load_key(op)
+                # Does this decl store that slot under a name?
+                store_name = name_storing_slot(decl.ops, oi)
+                next unless store_name
+                
+                # Keep earliest producer only
+                if !producers.key?(key)
+                  producers[key] = { name: store_name, decl_index: di }
+                  puts "LOAD_CSE: Found producer #{store_name} in decl #{di} for key #{key.inspect}" if debug
+                end
+              end
+            end
+
+            puts "LOAD_CSE: Found #{producers.size} unique load patterns" if debug
+
+            # Second pass: rewrite later identical loads to refs
+            optimizations = 0
+            new_decls = ir.decls.each_with_index.map do |decl, di|
+              new_ops = decl.ops.each_with_index.map do |op, oi|
+                next op unless op.tag == :load_input
+                
+                key = load_key(op)
+                prod = producers[key]
+                
+                # Only rewrite if producer is in an earlier decl
+                if prod && prod[:decl_index] < di
+                  optimizations += 1
+                  puts "LOAD_CSE: Replacing load_input in #{decl.name}[#{oi}] with ref to #{prod[:name]}" if debug
+                  Kumi::Core::IR::Ops.Ref(prod[:name])
+                else
+                  op
+                end
+              end
+              
+              Kumi::Core::IR::Decl.new(
+                name: decl.name, 
+                kind: decl.kind, 
+                shape: decl.shape, 
+                ops: new_ops
+              )
+            end
+
+            puts "LOAD_CSE: Applied #{optimizations} optimizations" if debug
+
+            new_ir = Kumi::Core::IR::Module.new(inputs: ir.inputs, decls: new_decls)
+            state.with(:ir_module, new_ir)
+          end
+
+          private
+
+          # Generate a unique key for a load_input operation based on its attributes
+          def load_key(op)
+            attrs = op.attrs || {}
+            [
+              :load_input,
+              attrs[:plan_id],
+              Array(attrs[:scope]),
+              !!attrs[:is_scalar],
+              !!attrs[:has_idx]
+            ]
+          end
+
+          # Find a store operation that names the given slot index
+          def name_storing_slot(ops, slot_id)
+            ops.each do |op|
+              next unless op.tag == :store
+              src = op.args && op.args[0]
+              return op.attrs[:name] if src == slot_id
+            end
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kumi/core/analyzer/passes/lower_to_ir_pass.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../../../support/ir_dump"
-
 module Kumi
   module Core
     module Analyzer
@@ -196,9 +194,6 @@ module Kumi
             when :reduce
               rs = Array(op.attrs[:result_scope] || [])
               rs.empty? ? SlotShape.scalar : SlotShape.vec(rs, has_idx: true)
-
-            when :lift
-              SlotShape.scalar # lift groups to nested Ruby arrays
             when :switch
               branch_shapes =
                 op.attrs[:cases].map { |(_, v)| determine_slot_shape(v, ops, access_plans) } +
@@ -217,7 +212,7 @@ module Kumi
               end
 
             else
-              SlotShape.scalar
+              raise "Op `#{op.tag}` not supported"
             end
           end
 
@@ -379,6 +374,7 @@ module Kumi
               when Syntax::InputReference
                 plan_id = pick_plan_id_for_input([expr.name], access_plans,
                                                  scope_plan: scope_plan, need_indices: need_indices)
+
                 plans    = access_plans.fetch(expr.name.to_s, [])
                 selected = plans.find { |p| p.accessor_key == plan_id }
                 scope    = selected ? selected.scope : []
@@ -430,6 +426,16 @@ module Kumi
               when Syntax::CallExpression
                 entry = Kumi::Registry.entry(expr.fn_name)
 
+                # Validate signature metadata from FunctionSignaturePass (read-only assertions)
+                validate_signature_metadata(expr, entry)
+
+                # Constant folding optimization: evaluate expressions with all literal arguments
+                if can_constant_fold?(expr, entry)
+                  folded_value = constant_fold(expr, entry)
+                  ops << Kumi::Core::IR::Ops.Const(folded_value)
+                  return ops.size - 1
+                end
+
                 if ENV["DEBUG_LOWER"] && has_nested_reducer?(expr)
                   puts "  NESTED_REDUCER_DETECTED in #{expr.fn_name} with req_scope=#{required_scope.inspect}"
                 end
@@ -441,22 +447,13 @@ module Kumi
                   # For comparison ops with nested reducers, we need to ensure
                   # the nested reducer gets the right required_scope (per-player)
                   # instead of the full dimensional scope from infer_expr_scope
-
-                  # Get the desired result scope from our scope plan (per-player scope)
-                  # This should be [:players] for per-player operations
                   plan = @join_reduce_plans[@current_decl]
                   target_scope = if plan.is_a?(Kumi::Core::Analyzer::Plans::Reduce) && plan.result_scope && !plan.result_scope.empty?
                                    plan.result_scope
                                  elsif required_scope && !required_scope.empty?
                                    required_scope
                                  else
-                                   # Try to infer per-player scope from the nested reducer argument
-                                   nested_reducer_arg = find_nested_reducer_arg(expr)
-                                   if nested_reducer_arg
-                                     infer_per_player_scope(nested_reducer_arg)
-                                   else
-                                     []
-                                   end
+                                   []
                                  end
 
                   puts "  NESTED_REDUCTION target_scope=#{target_scope.inspect}" if ENV["DEBUG_LOWER"]
@@ -759,44 +756,29 @@ module Kumi
               twin = :"#{cond.name}__vec"
               twin_meta = @vec_meta && @vec_meta[twin]
 
-              if cascade_scope && !Array(cascade_scope).empty?
-                # Consumer needs a grouped view of this declaration.
-                if twin_meta && twin_meta[:scope] == Array(cascade_scope)
-                  # We have a vectorized twin at exactly the required scope - use it!
-                  ops << Kumi::Core::IR::Ops.Ref(twin)
-                  ops.size - 1
-                else
-                  # Need to inline re-lower the referenced declaration's *expression*
-                  decl = @declarations.fetch(cond.name) { raise "unknown decl #{cond.name}" }
-                  slot = lower_expression(decl.expression, ops, access_plans, scope_plan,
-                                          true, Array(cascade_scope), cacheable: true)
-                  project_mask_to_scope(slot, cascade_scope, ops, access_plans)
-                end
-              else
-                # Plain (scalar) use, or already-materialized vec twin
-                ref = twin_meta ? twin : cond.name
-                ops << Kumi::Core::IR::Ops.Ref(ref)
-                ops.size - 1
-              end
+              raise "Missing cascade_scope" unless cascade_scope && !Array(cascade_scope).empty?
 
-            when Syntax::CallExpression
-              if cond.fn_name == :cascade_and
-                parts = cond.args.map { |a| lower_cascade_pred(a, cascade_scope, ops, access_plans, scope_plan) }
-                # They’re all @ cascade_scope (or scalar) now; align scalars broadcast, vecs already match.
-                parts.reduce do |acc, s|
-                  ops << Kumi::Core::IR::Ops.Map(:and, 2, acc, s)
-                  ops.size - 1
-                end
+              # Consumer needs a grouped view of this declaration.
+              if twin_meta && twin_meta[:scope] == Array(cascade_scope)
+                # We have a vectorized twin at exactly the required scope - use it!
+                ops << Kumi::Core::IR::Ops.Ref(twin)
+                ops.size - 1
               else
-                slot = lower_expression(cond, ops, access_plans, scope_plan,
-                                        true, Array(cascade_scope), cacheable: false)
+                # Need to inline re-lower the referenced declaration's *expression*
+                decl = @declarations.fetch(cond.name) { raise "unknown decl #{cond.name}" }
+                slot = lower_expression(decl.expression, ops, access_plans, scope_plan,
+                                        true, Array(cascade_scope), cacheable: true)
                 project_mask_to_scope(slot, cascade_scope, ops, access_plans)
               end
-
+            when Syntax::CallExpression
+              parts = cond.args.map { |a| lower_cascade_pred(a, cascade_scope, ops, access_plans, scope_plan) }
+              # They’re all @ cascade_scope (or scalar) now; align scalars broadcast, vecs already match.
+              parts.reduce do |acc, s|
+                ops << Kumi::Core::IR::Ops.Map(:and, 2, acc, s)
+                ops.size - 1
+              end
             else
-              slot = lower_expression(cond, ops, access_plans, scope_plan,
-                                      true, Array(cascade_scope), cacheable: false)
-              project_mask_to_scope(slot, cascade_scope, ops, access_plans)
+              raise "Unexpected Expression #{cond.class} in Cascade"
             end
           end
 
@@ -862,128 +844,94 @@ module Kumi
             end
           end
 
-          def find_nested_reducer_arg(expr)
-            return nil unless expr.is_a?(Kumi::Syntax::CallExpression)
+          # Make sure a boolean mask lives at exactly cascade_scope.
+          def project_mask_to_scope(slot, cascade_scope, ops, access_plans)
+            sh = determine_slot_shape(slot, ops, access_plans)
+            return slot if sh.scope == cascade_scope
+            return slot if sh.kind == :scalar
 
-            expr.args.each do |arg|
-              case arg
-              when Kumi::Syntax::CallExpression
-                entry = Kumi::Registry.entry(arg.fn_name)
-                return arg if entry&.reducer
+            cascade_scope = Array(cascade_scope)
+            slot_scope = Array(sh.scope)
 
-                nested = find_nested_reducer_arg(arg)
-                return nested if nested
-              end
+            # Check prefix compatibility
+            short, long = [cascade_scope, slot_scope].sort_by(&:length)
+            unless long.first(short.length) == short
+              raise "cascade condition scope #{slot_scope.inspect} is not prefix-compatible with #{cascade_scope.inspect}"
             end
-            nil
-          end
 
-          def infer_per_player_scope(reducer_expr)
-            return [] unless reducer_expr.is_a?(Kumi::Syntax::CallExpression)
-
-            # Look at the reducer's argument to determine the full scope
-            arg = reducer_expr.args.first
-            return [] unless arg
-
-            case arg
-            when Kumi::Syntax::InputElementReference
-              # For paths like [:players, :score_matrices, :session, :points]
-              # We want to keep [:players] and reduce over the rest
-              arg.path.empty? ? [] : [arg.path.first]
-            when Kumi::Syntax::CallExpression
-              # For nested expressions, get the deepest input path and take first element
-              deepest = find_deepest_input_path(arg)
-              deepest && !deepest.empty? ? [deepest.first] : []
-            else
-              []
-            end
-          end
+            return unless slot_scope.length < cascade_scope.length
 
-          def find_deepest_input_path(expr)
-            case expr
-            when Kumi::Syntax::InputElementReference
-              expr.path
-            when Kumi::Syntax::InputReference
-              [expr.name]
-            when Kumi::Syntax::CallExpression
-              paths = expr.args.map { |a| find_deepest_input_path(a) }.compact
-              paths.max_by(&:length)
-            else
-              nil
+            # Need to broadcast UP: slot scope is shorter, needs to be aligned to cascade scope
+            # Find a target vector that already has the cascade scope
+            target_slot = nil
+            ops.each_with_index do |op, i|
+              next unless %i[load_input map].include?(op.tag)
+
+              shape = determine_slot_shape(i, ops, access_plans)
+              if shape.kind == :vec && shape.scope == cascade_scope && shape.has_idx
+                target_slot = i
+                break
+              end
             end
+
+            ops << Kumi::Core::IR::Ops.AlignTo(target_slot, slot, to_scope: cascade_scope, on_missing: :error, require_unique: true)
+            ops.size - 1
           end
 
-          # Make sure a boolean mask lives at exactly cascade_scope.
-          def project_mask_to_scope(slot, cascade_scope, ops, access_plans)
-            sh = determine_slot_shape(slot, ops, access_plans)
-            return slot if sh.scope == cascade_scope
+          # Constant folding optimization helpers
+          def can_constant_fold?(expr, entry)
+            return false unless entry&.fn # Skip if function not found
+            return false if entry.reducer # Skip reducer functions for now
+            return false if expr.args.empty? # Need at least one argument
 
-            # If we have a scalar condition but need it at cascade scope, broadcast it
-            if sh.kind == :scalar && cascade_scope && !Array(cascade_scope).empty?
-              # Find a target vector that already has the cascade scope
-              target_slot = nil
-              ops.each_with_index do |op, i|
-                next unless %i[load_input map].include?(op.tag)
+            # Check if all arguments are literals
+            expr.args.all? { |arg| arg.is_a?(Syntax::Literal) }
+          end
 
-                shape = determine_slot_shape(i, ops, access_plans)
-                if shape.kind == :vec && shape.scope == Array(cascade_scope) && shape.has_idx
-                  target_slot = i
-                  break
-                end
-              end
+          def validate_signature_metadata(expr, entry)
+            # Get the node index to access signature metadata
+            node_index = get_state(:node_index, required: false)
+            return unless node_index
 
-              return slot unless target_slot
+            node_entry = node_index[expr.object_id]
+            return unless node_entry
 
-              ops << Kumi::Core::IR::Ops.AlignTo(target_slot, slot, to_scope: Array(cascade_scope), on_missing: :error,
-                                                                    require_unique: true)
-              return ops.size - 1
+            metadata = node_entry[:metadata]
+            return unless metadata
 
-              # Can't broadcast, use as-is
+            # Validate that dropped axes make sense for reduction functions
+            if entry&.reducer && metadata[:dropped_axes]
+              dropped_axes = metadata[:dropped_axes]
+              unless dropped_axes.is_a?(Array)
+                raise "Invalid dropped_axes metadata for reducer #{expr.fn_name}: expected Array, got #{dropped_axes.class}"
+              end
 
+              # For reductions, we should have at least one dropped axis (or empty for scalar reductions)
+              puts "  SIGNATURE[#{expr.fn_name}] dropped_axes: #{dropped_axes.inspect}" if ENV["DEBUG_LOWER"]
             end
 
-            return slot if sh.kind == :scalar
-
-            cascade_scope = Array(cascade_scope)
-            slot_scope = Array(sh.scope)
-
-            # Check prefix compatibility
-            short, long = [cascade_scope, slot_scope].sort_by(&:length)
-            unless long.first(short.length) == short
-              raise "cascade condition scope #{slot_scope.inspect} is not prefix-compatible with #{cascade_scope.inspect}"
+            # Validate join_policy is recognized
+            if metadata[:join_policy] && !%i[zip product].include?(metadata[:join_policy])
+              raise "Invalid join_policy for #{expr.fn_name}: #{metadata[:join_policy].inspect}"
             end
 
-            if slot_scope.length < cascade_scope.length
-              # Need to broadcast UP: slot scope is shorter, needs to be aligned to cascade scope
-              # Find a target vector that already has the cascade scope
-              target_slot = nil
-              ops.each_with_index do |op, i|
-                next unless %i[load_input map].include?(op.tag)
+            # Warn about join_policy when no join op exists yet (future integration point)
+            return unless metadata[:join_policy] && ENV["DEBUG_LOWER"]
 
-                shape = determine_slot_shape(i, ops, access_plans)
-                if shape.kind == :vec && shape.scope == cascade_scope && shape.has_idx
-                  target_slot = i
-                  break
-                end
-              end
+            puts "  SIGNATURE[#{expr.fn_name}] join_policy: #{metadata[:join_policy]} (join op not yet implemented)"
+          end
 
-              if target_slot
-                ops << Kumi::Core::IR::Ops.AlignTo(target_slot, slot, to_scope: cascade_scope, on_missing: :error, require_unique: true)
-                ops.size - 1
-              else
-                # Fallback: use the slot itself (might not work but worth trying)
-                ops << Kumi::Core::IR::Ops.AlignTo(slot, slot, to_scope: cascade_scope, on_missing: :error, require_unique: true)
-                ops.size - 1
-              end
-            else
-              # Need to reduce DOWN: slot scope is longer, reduce extra dimensions
-              extra_axes = slot_scope - cascade_scope
-              if extra_axes.empty?
-                slot # should not happen due to early return above
-              else
-                ops << Kumi::Core::IR::Ops.Reduce(:any?, extra_axes, cascade_scope, [], slot)
-                ops.size - 1
-              end
+          def constant_fold(expr, entry)
+            literal_values = expr.args.map(&:value)
+
+            begin
+              # Call the function with literal values at compile time
+              entry.fn.call(*literal_values)
+            rescue StandardError => e
+              # If constant folding fails, fall back to runtime evaluation
+              # This shouldn't happen with pure functions, but be defensive
+              puts "Constant folding failed for #{expr.fn_name}: #{e.message}" if ENV["DEBUG_LOWER"]
+              raise "Cannot constant fold #{expr.fn_name}: #{e.message}"
             end
           end
         end

data/lib/kumi/core/analyzer/passes/toposorter.rb

@@ -8,18 +8,54 @@ module Kumi
         # RESPONSIBILITY: Compute topological ordering of declarations, allowing safe conditional cycles
         # DEPENDENCIES: :dependencies from DependencyResolver, :declarations from NameIndexer, :cascades from UnsatDetector
         # PRODUCES: :evaluation_order - Array of declaration names in evaluation order
+        #           :node_index - Hash mapping object_id to node metadata for later passes
         # INTERFACE: new(schema, state).run(errors)
         class Toposorter < PassBase
           def run(errors)
             dependency_graph = get_state(:dependencies, required: false) || {}
             definitions = get_state(:declarations, required: false) || {}
 
+            # Create node index for later passes to use
+            node_index = build_node_index(definitions)
             order = compute_topological_order(dependency_graph, definitions, errors)
-            state.with(:evaluation_order, order)
+            
+            state.with(:evaluation_order, order).with(:node_index, node_index)
           end
 
           private
 
+          def build_node_index(definitions)
+            index = {}
+            
+            # Walk all declarations and their expressions to index every node
+            definitions.each_value do |decl|
+              index_node_recursive(decl, index)
+            end
+            
+            index
+          end
+          
+          def index_node_recursive(node, index)
+            return unless node
+            
+            # Index this node by its object_id
+            index[node.object_id] = {
+              node: node,
+              type: node.class.name.split('::').last,
+              metadata: {}
+            }
+            
+            # Use the same approach as the visitor pattern - recursively index all children
+            if node.respond_to?(:children)
+              node.children.each { |child| index_node_recursive(child, index) }
+            end
+            
+            # Index expression for declaration nodes
+            if node.respond_to?(:expression)
+              index_node_recursive(node.expression, index)
+            end
+          end
+
           def compute_topological_order(graph, definitions, errors)
             temp_marks = Set.new
             perm_marks = Set.new

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "json"
+require "set"
+
+module Kumi
+  module Core
+    module Analyzer
+      module StateSerde
+        module_function
+
+        # Exact round-trip (recommended for resume)
+        def dump_marshal(state)
+          Marshal.dump({ v: 1, data: state.to_h })
+        end
+
+        def load_marshal(bytes)
+          payload = Marshal.load(bytes)
+          ::Kumi::Core::Analyzer::AnalysisState.new(payload[:data])
+        end
+
+        # Human-readable snapshot (best-effort; not guaranteed resumable)
+        def dump_json(state, pretty: true)
+          h = encode_json_safe(state.to_h)
+          pretty ? JSON.pretty_generate(h) : JSON.generate(h)
+        end
+
+        def load_json(json_str)
+          h = JSON.parse(json_str)  # Don't symbolize keys - let decode_json_safe handle it
+          ::Kumi::Core::Analyzer::AnalysisState.new(decode_json_safe(h))
+        end
+
+        # ---- helpers ----
+        def encode_json_safe(x)
+          case x
+          when Hash  then x.transform_keys(&:to_s).transform_values { |v| encode_json_safe(v) }
+          when Array then x.map { |v| encode_json_safe(v) }
+          when Set   then { "$set" => x.to_a.map { |v| encode_json_safe(v) } }
+          when Symbol then { "$sym" => x.to_s }
+          when ::Kumi::Core::IR::Module, ::Kumi::Core::IR::Decl, ::Kumi::Core::IR::Op
+            { "$ir" => x.inspect }
+          else x
+          end
+        end
+
+        def decode_json_safe(x)
+          case x
+          when Hash
+            # Check for special encoding markers first (before key transformation)
+            if    x.key?("$sym") then x["$sym"].to_sym
+            elsif x.key?("$set") then Set.new(x["$set"].map { |item| decode_json_safe(item) })
+            elsif x.key?("$ir")  then x["$ir"]  # Keep as string inspection for JSON round-trip
+            else 
+              # Regular hash - transform keys to symbols and recursively decode values
+              x.transform_keys(&:to_sym).transform_values { |value| decode_json_safe(value) }
+            end
+          when Array then x.map { |item| decode_json_safe(item) }
+          else x
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kumi/core/analyzer/structs/access_plan.rb

@@ -3,17 +3,19 @@
 module Kumi
   module Core
     module Analyzer
-      # One plan for a specific path and mode (path:mode)
-      AccessPlan = Struct.new(:path, :containers, :leaf, :scope, :depth, :mode,
-                              :on_missing, :key_policy, :operations, keyword_init: true) do
-        def initialize(path:, containers:, leaf:, scope:, depth:, mode:, on_missing:, key_policy:, operations:)
-          super
-          freeze
-        end
+      module Structs
+        # One plan for a specific path and mode (path:mode)
+        AccessPlan = Struct.new(:path, :containers, :leaf, :scope, :depth, :mode,
+                                :on_missing, :key_policy, :operations, keyword_init: true) do
+          def initialize(path:, containers:, leaf:, scope:, depth:, mode:, on_missing:, key_policy:, operations:)
+            super
+            freeze
+          end
 
-        def accessor_key = "#{path}:#{mode}"
-        def ndims        = depth
-        def scalar?      = depth.zero?
+          def accessor_key = "#{path}:#{mode}"
+          def ndims        = depth
+          def scalar?      = depth.zero?
+        end
       end
     end
   end

data/lib/kumi/core/compiler/access_planner.rb

@@ -73,7 +73,7 @@ module Kumi
           modes.each do |mode|
             operations = build_operations(path, mode)
 
-            list << Kumi::Core::Analyzer::AccessPlan.new(
+            list << Kumi::Core::Analyzer::Structs::AccessPlan.new(
               path: base[:path],
               containers: base[:containers],
               leaf: base[:leaf],
@@ -148,7 +148,8 @@ module Kumi
               ops << enter_hash(seg)
               puts "      Added: enter_hash('#{seg}')" if ENV["DEBUG_ACCESSOR_OPS"]
             else
-              raise ArgumentError, "Invalid parent :container '#{container}' for segment '#{seg}'. Expected :array, :object, :hash, or nil (root)"
+              raise ArgumentError,
+                    "Invalid parent :container '#{container}' for segment '#{seg}'. Expected :array, :object, :hash, or nil (root)"
             end
 
             parent_meta = node

data/lib/kumi/core/function_registry/collection_functions.rb

@@ -11,7 +11,9 @@ module Kumi
             empty?: FunctionBuilder.collection_unary(:empty?, "Check if collection is empty", :empty?, reducer: true,
                                                                                                        structure_function: true),
             size: FunctionBuilder::Entry.new(
-              fn: ->(collection) { collection.size },
+              fn: lambda { |collection|
+                collection.size
+              },
               arity: 1,
               param_types: [:any],
               return_type: :integer,