kumi 0.0.18 → 0.0.20

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

@@ -1,298 +0,0 @@
-# frozen_string_literal: true
-
-module Kumi
-  module Core
-    module FunctionRegistry
-      # Collection manipulation and query functions
-      module CollectionFunctions
-        def self.definitions
-          {
-            # Collection queries (these are reducers - they reduce arrays to scalars)
-            empty?: FunctionBuilder.collection_unary(:empty?, "Check if collection is empty", :empty?, reducer: true,
-                                                                                                       structure_function: true),
-            size: FunctionBuilder::Entry.new(
-              fn: lambda { |collection|
-                collection.size
-              },
-              arity: 1,
-              param_types: [:any],
-              return_type: :integer,
-              description: "Get size of collection",
-              param_modes: { fixed: [:elem] }, # take a vector argument elementwise
-              reducer: true,
-              structure_function: true
-            ),
-
-            # Element access
-            first: FunctionBuilder::Entry.new(
-              fn: lambda(&:first),
-              arity: 1,
-              param_types: [Kumi::Core::Types.array(:any)],
-              return_type: :any,
-              description: "Get first element of collection",
-              reducer: true
-            ),
-
-            last: FunctionBuilder::Entry.new(
-              fn: lambda(&:last),
-              arity: 1,
-              param_types: [Kumi::Core::Types.array(:any)],
-              return_type: :any,
-              description: "Get last element of collection",
-              reducer: true
-            ),
-
-            # Mathematical operations on collections
-            sum: FunctionBuilder::Entry.new(
-              fn: lambda(&:sum),
-              arity: 1,
-              param_types: [Kumi::Core::Types.array(:float)],
-              return_type: :float,
-              description: "Sum all numeric elements in collection",
-              reducer: true
-            ),
-
-            min: FunctionBuilder::Entry.new(
-              fn: lambda(&:min),
-              arity: 1,
-              param_types: [Kumi::Core::Types.array(:float)],
-              return_type: :float,
-              description: "Find minimum value in numeric collection",
-              reducer: true
-            ),
-
-            max: FunctionBuilder::Entry.new(
-              fn: lambda(&:max),
-              arity: 1,
-              param_types: [Kumi::Core::Types.array(:float)],
-              return_type: :float,
-              description: "Find maximum value in numeric collection",
-              reducer: true,
-              param_modes: { fixed: [:elem] } # first param is the vector being reduced
-            ),
-
-            # Collection operations
-            include?: FunctionBuilder::Entry.new(
-              fn: ->(collection, element) { collection.include?(element) },
-              arity: 2,
-              param_types: [Kumi::Core::Types.array(:any), :any],
-              return_type: :boolean,
-              description: "Check if collection includes element"
-            ),
-
-            reverse: FunctionBuilder::Entry.new(
-              fn: lambda(&:reverse),
-              arity: 1,
-              param_types: [Kumi::Core::Types.array(:any)],
-              return_type: Kumi::Core::Types.array(:any),
-              description: "Reverse collection order"
-            ),
-
-            sort: FunctionBuilder::Entry.new(
-              fn: lambda(&:sort),
-              arity: 1,
-              param_types: [Kumi::Core::Types.array(:any)],
-              return_type: Kumi::Core::Types.array(:any),
-              description: "Sort collection"
-            ),
-
-            unique: FunctionBuilder::Entry.new(
-              fn: lambda(&:uniq),
-              arity: 1,
-              param_types: [Kumi::Core::Types.array(:any)],
-              return_type: Kumi::Core::Types.array(:any),
-              description: "Remove duplicate elements from collection"
-            ),
-
-            # Array transformation functions
-            flatten: FunctionBuilder::Entry.new(
-              fn: ->(array) { array.flatten },
-              arity: 1,
-              param_types: [Kumi::Core::Types.array(:any)],
-              return_type: Kumi::Core::Types.array(:any),
-              description: "Flatten nested arrays into a single array",
-              structure_function: true,
-              reducer: true
-            ),
-
-            flatten_one: FunctionBuilder::Entry.new(
-              fn: ->(array) { array.flatten(1) },
-              arity: 1,
-              param_types: [Kumi::Core::Types.array(:any)],
-              return_type: Kumi::Core::Types.array(:any),
-              description: "Flatten nested arrays by one level only",
-              structure_function: true
-            ),
-
-            to_array: FunctionBuilder::Entry.new(
-              fn: ->(vals) { vals },
-              arity: 1,
-              param_types: [Kumi::Core::Types.array(:any)],
-              return_type: Kumi::Core::Types.array(:any),
-              description: "Collect vector rows into a Ruby array",
-              reducer: true
-            ),
-
-            # Mathematical transformation functions
-            map_multiply: FunctionBuilder::Entry.new(
-              fn: ->(collection, factor) { collection.map { |x| x * factor } },
-              arity: 2,
-              param_types: [Kumi::Core::Types.array(:float), :float],
-              return_type: Kumi::Core::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::Core::Types.array(:float), :float],
-              return_type: Kumi::Core::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::Core::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::Core::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::Core::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::Core::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::Core::Types.array(:any)],
-              return_type: Kumi::Core::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::Core::Types.array(:any)],
-              return_type: Kumi::Core::Types.array(:integer),
-              description: "Generate array of indices for the collection"
-            ),
-
-            # Conditional aggregation functions
-            count_if: FunctionBuilder::Entry.new(
-              fn: ->(condition_array) { condition_array.count(true) },
-              arity: 1,
-              param_types: [Kumi::Core::Types.array(:boolean)],
-              return_type: :integer,
-              description: "Count number of true values in boolean array",
-              reducer: true
-            ),
-
-            sum_if: FunctionBuilder::Entry.new(
-              fn: lambda { |value_array, condition_array|
-                value_array.zip(condition_array).sum { |value, condition| condition ? value : 0 }
-              },
-              arity: 2,
-              param_types: [Kumi::Core::Types.array(:float), Kumi::Core::Types.array(:boolean)],
-              return_type: :float,
-              description: "Sum values where corresponding condition is true",
-              reducer: true
-            ),
-
-            avg_if: FunctionBuilder::Entry.new(
-              fn: lambda { |value_array, condition_array|
-                pairs = value_array.zip(condition_array)
-                true_values = pairs.filter_map { |value, condition| value if condition }
-                return 0.0 if true_values.empty?
-
-                true_values.sum.to_f / true_values.size
-              },
-              arity: 2,
-              param_types: [Kumi::Core::Types.array(:float), Kumi::Core::Types.array(:boolean)],
-              return_type: :float,
-              description: "Average values where corresponding condition is true",
-              reducer: true
-            ),
-
-            # Flattening utilities for hierarchical data
-            any_across: FunctionBuilder::Entry.new(
-              fn: ->(nested_array) { nested_array.flatten.any? },
-              arity: 1,
-              param_types: [Kumi::Core::Types.array(:any)],
-              return_type: :boolean,
-              description: "Check if any element is truthy across all nested levels",
-              reducer: true
-            ),
-
-            all_across: FunctionBuilder::Entry.new(
-              fn: ->(nested_array) { nested_array.flatten.all? },
-              arity: 1,
-              param_types: [Kumi::Core::Types.array(:any)],
-              return_type: :boolean,
-              description: "Check if all elements are truthy across all nested levels",
-              reducer: true
-            ),
-
-            count_across: FunctionBuilder::Entry.new(
-              fn: ->(nested_array) { nested_array.flatten.size },
-              arity: 1,
-              param_types: [Kumi::Core::Types.array(:any)],
-              return_type: :integer,
-              description: "Count total elements across all nested levels",
-              reducer: true
-            )
-          }
-        end
-      end
-    end
-  end
-end

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

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module Kumi
-  module Core
-    module FunctionRegistry
-      # Comparison and equality functions
-      module ComparisonFunctions
-        def self.definitions
-          {
-            # Equality operators
-            :== => FunctionBuilder.equality(:==, "Equality comparison", :==),
-            :!= => FunctionBuilder.equality(:!=, "Inequality comparison", :!=),
-
-            # Comparison operators
-            :> => FunctionBuilder.comparison(:>, "Greater than comparison", :>),
-            :< => FunctionBuilder.comparison(:<, "Less than comparison", :<),
-            :>= => FunctionBuilder.comparison(:>=, "Greater than or equal comparison", :>=),
-            :<= => FunctionBuilder.comparison(:<=, "Less than or equal comparison", :<=),
-
-            # Range comparison
-            :between? => FunctionBuilder::Entry.new(
-              fn: ->(value, min, max) { value.between?(min, max) },
-              arity: 3,
-              param_types: %i[float float float],
-              return_type: :boolean,
-              description: "Check if value is between min and max"
-            )
-          }
-        end
-      end
-    end
-  end
-end

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

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-module Kumi
-  module Core
-    module FunctionRegistry
-      module ConditionalFunctions
-        def self.definitions
-          {
-            # a ? b : c
-            conditional: FunctionBuilder::Entry.new(
-              fn: ->(condition, true_value, false_value) { condition ? true_value : false_value },
-              arity: 3,
-              param_types: %i[boolean any any],
-              return_type: :any,
-              # all three are element-wise (scalars auto-broadcast)
-              param_modes: { fixed: %i[elem elem elem] },
-              description: "Ternary conditional operator"
-            ),
-
-            # if(cond, then, else=nil)
-            if: FunctionBuilder::Entry.new(
-              fn: ->(condition, true_value, false_value = nil) { condition ? true_value : false_value },
-              # keep arity=3; the last arg is optional at call time
-              arity: 3,
-              param_types: %i[boolean any any],
-              return_type: :any,
-              param_modes: { fixed: %i[elem elem elem] },
-              description: "If-then-else conditional",
-              reducer: false,
-              structure_function: false
-            ),
-
-            # coalesce(a, b, c, ...)
-            coalesce: FunctionBuilder::Entry.new(
-              fn: ->(*values) { values.find { |v| !v.nil? } },
-              arity: -1, # variadic
-              param_types: [:any],
-              return_type: :any,
-              # every variadic arg participates element-wise
-              param_modes: { fixed: [], variadic: :elem },
-              description: "Return first non-nil value"
-            )
-          }
-        end
-      end
-    end
-  end
-end

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

@@ -1,184 +0,0 @@
-# frozen_string_literal: true
-
-module Kumi
-  module Core
-    module FunctionRegistry
-      class FunctionBuilder
-        # Rich, defaulted function entry
-        class Entry
-          # NOTE: Keep ctor args minimal; everything else has sensible defaults.
-          attr_reader :fn, :arity, :param_types, :return_type, :description,
-                      :reducer, :structure_function, :param_modes, :param_info
-
-          # param_modes:  nil | ->(argc){[:elem,:scalar,...]} | {fixed: [...], variadic: :elem|:scalar}
-          # param_info:   nil | ->(argc){[specs]} | {fixed: [...], variadic: {…}}
-          #   where a spec is: { name:, type:, mode:, required:, default:, doc: }
-          def initialize(
-            fn:,
-            arity: nil,                 # Integer (>=0) or -1 / nil for variadic
-            param_types: nil,           # defaults to [:any] * arity (when fixed)
-            return_type: :any,
-            description: "",
-            reducer: false,
-            structure_function: false,
-            param_modes: nil,
-            param_info: nil
-          )
-            @fn                 = fn
-            @arity              = arity
-            @param_types        = param_types || default_param_types(arity)
-            @return_type        = return_type
-            @description        = description
-            @reducer            = !!reducer
-            @structure_function = !!structure_function
-            @param_modes        = normalize_param_modes(param_modes, arity)
-            @param_info         = normalize_param_info(param_info, arity, @param_types)
-          end
-
-          # Concrete modes for a call site
-          def param_modes_for(argc)
-            pm = @param_modes
-            return pm.call(argc) if pm.respond_to?(:call)
-
-            fixed = Array(pm[:fixed] || [])
-            return fixed.first(argc) if argc <= fixed.size
-
-            fixed + Array.new(argc - fixed.size, pm.fetch(:variadic, :elem))
-          end
-
-          # Concrete param specs for a call site
-          # → [{name:, type:, mode:, required:, default:, doc:}, ...]
-          def param_specs_for(argc)
-            base = if @param_info.respond_to?(:call)
-                     @param_info.call(argc)
-                   else
-                     fixed = Array(@param_info[:fixed] || [])
-                     if argc <= fixed.size
-                       fixed.first(argc)
-                     else
-                       fixed + Array.new(argc - fixed.size, @param_info.fetch(:variadic, {}))
-                     end
-                   end
-
-            modes = param_modes_for(argc)
-            types = expand_types_for(argc)
-
-            base.each_with_index.map do |spec, i|
-              {
-                name: spec[:name]     || auto_name(i),
-                type: spec[:type]     || types[i] || :any,
-                mode: spec[:mode]     || modes[i] || :elem,
-                required: spec.key?(:required) ? spec[:required] : true,
-                default: spec[:default],
-                doc: spec[:doc] || ""
-              }
-            end
-          end
-
-          private
-
-          def default_param_types(arity)
-            if arity.is_a?(Integer) && arity >= 0
-              Array.new(arity, :any)
-            else
-              [] # variadic → types resolved per call
-            end
-          end
-
-          def expand_types_for(argc)
-            if @param_types.nil? || @param_types.empty?
-              Array.new(argc, :any)
-            elsif @param_types.length >= argc
-              @param_types.first(argc)
-            else
-              @param_types + Array.new(argc - @param_types.length, @param_types.last || :any)
-            end
-          end
-
-          def normalize_param_modes(pm, arity)
-            return pm if pm
-
-            # Default: everything element-wise/broadcastable
-            ->(argc) { Array.new(argc, :elem) }
-          end
-
-          def normalize_param_info(info, arity, types)
-            return info if info
-
-            # Default: synthesize from types/modes at call time
-            ->(argc) { Array.new(argc) { {} } }
-          end
-
-          def auto_name(i) = :"arg#{i + 1}"
-        end
-
-        # ===== Helper constructors (unchanged usage; now benefit from defaults) =====
-
-        def self.comparison(_name, description, op)
-          Entry.new(
-            fn: ->(a, b) { a.public_send(op, b) },
-            arity: 2, param_types: %i[float float],
-            return_type: :boolean, description: description
-          )
-        end
-
-        def self.equality(_name, description, op)
-          Entry.new(
-            fn: ->(a, b) { a.public_send(op, b) },
-            arity: 2, param_types: %i[any any],
-            return_type: :boolean, description: description
-          )
-        end
-
-        def self.math_binary(_name, description, op, return_type: :float)
-          Entry.new(
-            fn: ->(a, b) { a.public_send(op, b) },
-            arity: 2, param_types: %i[float float],
-            return_type: return_type, description: description
-          )
-        end
-
-        def self.math_unary(_name, description, op, return_type: :float)
-          Entry.new(
-            fn: proc(&op),
-            arity: 1, param_types: [:float],
-            return_type: return_type, description: description
-          )
-        end
-
-        def self.string_unary(_name, description, op)
-          Entry.new(
-            fn: ->(s) { s.to_s.public_send(op) },
-            arity: 1, param_types: [:string],
-            return_type: :string, description: description
-          )
-        end
-
-        def self.string_binary(_name, description, op, return_type: :string)
-          Entry.new(
-            fn: ->(s, x) { s.to_s.public_send(op, x.to_s) },
-            arity: 2, param_types: %i[string string],
-            return_type: return_type, description: description
-          )
-        end
-
-        def self.logical_variadic(_name, description, op)
-          Entry.new(
-            fn: ->(*conds) { conds.flatten.public_send(op) },
-            arity: -1, param_types: [:boolean],
-            return_type: :boolean, description: description
-          )
-        end
-
-        def self.collection_unary(_name, description, op, return_type: :boolean, reducer: false, structure_function: false)
-          Entry.new(
-            fn: proc(&op),
-            arity: 1, param_types: [Kumi::Core::Types.array(:any)],
-            return_type: return_type, description: description,
-            reducer: reducer, structure_function: structure_function
-          )
-        end
-      end
-    end
-  end
-end