mug 2.0.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ae2889ece035a30a218babac3772fe51854ade8ef1164885502bd5d3ff6bb39b
-  data.tar.gz: deb9c3a27eb1cf6684b56fe6dfc1fbb9318a33ba432ea5c5cd714917a76bd563
+  metadata.gz: fb09c157ead059eeb09c4b9f0686ec84636d08cbb46755e838e561a21645aa1e
+  data.tar.gz: 06c8ee0f76b4763199876bdd76bf6a28ed987e588248c8683108c53409943e77
 SHA512:
-  metadata.gz: 7734746e0817ef7ceb90a1a7742486993c2f6956d0f76ed3968e4edb6c8e7a181ffb148cb7de5e94e3cafe817632626e5a9a706ca889aee6796e9cf1a1f43811
-  data.tar.gz: 7a1ce3c096ddf71af5c87eade7f4b727fd32af167ba83a8e42b98fa120609e4414e38341d981274fc8d383a3a43da65c8a1d7bf3f3bfabd1d42a3f0cabd34ca2
+  metadata.gz: 4a3e1a610087afa31dca23c0b4f72f3fe4959fd13f45e39c17ea86f058293926a97da12beceea748601a615bb1f10d5bcb0f6f6b3dc7b1c00a2b50702cc5a2b2
+  data.tar.gz: 169f4dba3371163df8f793ae66c0182fd29de7bff65546324e121466837d28d5d718277240eb859b54aefecc7063ff5c349009b85ad8f721028a5faad2b7dd5d

data/lib/mug/apply.rb

@@ -1,14 +1,37 @@
-
 class Proc
-  #
-  # Curries this Proc and partially applies parameters.
-  # If a sufficient number of arguments are supplied, it passes the
-  # supplied arguments to the original proc and returns the result.
-  # Otherwise, returns another curried proc that takes the rest of
-  # arguments.
-  #
-  def apply(*args)
-    curry.call(*args)
+  # TruffleRuby's Proc#curry does not perform partial application for
+  # non-lambda procs; it invokes the proc immediately regardless of the
+  # number of arguments supplied.
+  if RUBY_ENGINE == 'truffleruby'
+    #
+    # Curries this Proc and partially applies parameters.
+    # If a sufficient number of arguments are supplied, it passes the
+    # supplied arguments to the original proc and returns the result.
+    # Otherwise, returns another curried proc that takes the rest of
+    # arguments.
+    #
+    def apply(*args)
+      n = arity < 0 ? -arity - 1 : arity
+      if lambda?
+        curry(n).call(*args)
+      elsif args.length >= n
+        call(*args)
+      else
+        proc {|*more| call(*args, *more) }
+      end
+    end
+  else
+    #
+    # Curries this Proc and partially applies parameters.
+    # If a sufficient number of arguments are supplied, it passes the
+    # supplied arguments to the original proc and returns the result.
+    # Otherwise, returns another curried proc that takes the rest of
+    # arguments.
+    #
+    def apply(*args)
+      n = arity < 0 ? -arity - 1 : arity
+      curry(n).call(*args)
+    end
   end
 end
 
@@ -21,7 +44,8 @@ class Method
   # arguments.
   #
   def apply(*args)
-    curry.call(*args)
+    n = arity < 0 ? -arity - 1 : arity
+    curry(n).call(*args)
   end
 end
 

data/lib/mug/functional.rb

@@ -0,0 +1,191 @@
+
+class Proc
+
+  #
+  # Composes a sequence of functions.
+  #
+  # A function is anything that responds to #to_proc, so
+  # symbols are allowed.
+  #
+  # This proc is prepended at the start of the composition.
+  #
+  def compose *funcs
+    return self if funcs.empty?
+    self >> funcs.map(&:to_proc).reduce(:>>)
+  end
+
+  #
+  # Composes a sequence of functions.
+  #
+  # A function is anything that responds to #to_proc, so
+  # symbols are allowed.
+  #
+  # This proc is appended at the end of the composition.
+  #
+  def precompose *funcs
+    return self if funcs.empty?
+    self << funcs.map(&:to_proc).reduce(:>>)
+  end
+
+  #
+  # Applies this function to each element of +args+ in order.
+  #
+  # `proc.mapply(*args)` is equivalent to `args.map(&proc)`
+  #
+  def mapply *args
+    args.map {|*a| self.call(*a) }
+  end
+
+  #
+  # Generates a function that memoizes this one. For a given
+  # set of parameters, this proc is only invoked once; the
+  # result is remembered for subsequent invocations.
+  #
+  def memoize
+    cache = {}
+    lambda do |*args|
+      cache.fetch(args) {|_| cache[args] = self.call(*args) }
+    end
+  end
+  alias memoise memoize
+
+  #
+  # Generates a function that reorders its arguments according
+  # to +indices+ and calls this function on the resulting
+  # list.
+  #
+  # The +arity+ parameter controls how mismatches in length
+  # between the arguments and indices are handled:
+  #   :min       - cap at the minimum of args and indices (default)
+  #   :max       - use the maximum; nil-fill if args are short,
+  #                pass-through if args are long
+  #   :indices   - always use indices.size; nil for out-of-bounds
+  #   :arguments - always use args.size; excess positions pass
+  #                through at their original index
+  #
+  def trans *indices, arity: :min
+    case arity
+    when :min
+      lambda do |*a|
+        n = [a.size, indices.size].min
+        list = (0...n).map {|i| a[indices[i]] }
+        self.call(*list)
+      end
+    when :indices
+      lambda do |*a|
+        list = (0...indices.size).map {|i| a[indices[i]] }
+        self.call(*list)
+      end
+    when :arguments
+      lambda do |*a|
+        list = (0...a.size).map do |i|
+          i < indices.size ? a[indices[i]] : a[i]
+        end
+        self.call(*list)
+      end
+    when :max
+      lambda do |*a|
+        n = [a.size, indices.size].max
+        list = (0...n).map do |i|
+          i < indices.size ? a[indices[i]] : a[i]
+        end
+        self.call(*list)
+      end
+    else
+      raise ArgumentError, "unknown arity mode: #{arity.inspect}"
+    end
+  end
+
+  #
+  # Generates a function that maps its arguments to each of
+  # +funcs+ in order.
+  #
+  def zipmap *funcs
+    lambda do |*args|
+      n = [args.size, funcs.size].min
+      mapped = (0...n).map do |i|
+        func = funcs[i]
+        arg  = args[i]
+
+        if func.nil?
+          arg
+        elsif func.respond_to? :call
+          func.call arg
+        elsif func.is_a? Symbol
+          arg.__send__ func
+        else
+          raise TypeError, "expected callable, Symbol, or nil; got #{func.class}"
+        end
+      end
+      self.call(*mapped)
+    end
+  end
+
+  class << self
+
+    #
+    # Generates a function that maps its arguments to the
+    # given +funcs+ list in order.
+    #
+    def juxt *funcs
+      lambda do |*args|
+        funcs.map {|f| f.to_proc.call(*args) }
+      end
+    end
+
+    #
+    # Generates an identity function that always returns its argument exactly.
+    #
+    def identity
+      lambda {|x| x }
+    end
+
+    #
+    # Generates a constant function that always returns +c+.
+    #
+    # Note that it always returns the same object, so mutations will stick
+    # from invocation to invocation.
+    #
+    def const c
+      lambda {|*| c }
+    end
+
+  end
+end
+
+class Enumerator
+  class << self
+
+    #
+    # Creates an Enumerator that can unfold a sequence from a given seed.
+    #
+    def unfold(seed, &blk)
+      raise ArgumentError, 'no block given' unless block_given?
+      Enumerator.new do |y|
+        loop do
+          result = blk.call(seed)
+          break if result.nil?
+          value, seed = result
+          y << value
+        end
+      end
+    end
+
+  end
+end
+
+=begin
+Copyright (c) 2014-2026, Matthew Kerwin <matthew@kerwin.net.au>
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+=end

data/lib/mug.rb

@@ -17,6 +17,7 @@ require_relative 'mug/enumerable/chain'
 require_relative 'mug/enumerable/counts'
 require_relative 'mug/enumerable/hash-like'
 require_relative 'mug/fragile-method-chain'
+require_relative 'mug/functional'
 require_relative 'mug/hash/fetch-assign'
 require_relative 'mug/hash/map'
 require_relative 'mug/hash/merge'

data/test/test-enumerable-chain.rb

@@ -15,7 +15,8 @@ class Test_enumerable_chain < Test::Unit::TestCase
     ]
 
     enum = a.chain(b, c)
-    assert_kind_of( Enumerator, enum )
+    assert( enum.kind_of?(Enumerator) || enum.kind_of?(Enumerator::Chain),
+            "expected Enumerator or Enumerator::Chain, got #{enum.class}" )
 
     result = []
     enum.each do |*x|

data/test/test-functional.rb

@@ -0,0 +1,242 @@
+require 'test/unit'
+$VERBOSE = true
+
+require_relative '../lib/mug/functional'
+
+class Test_functional_compose < Test::Unit::TestCase
+  def test_compose__readme_example
+    prc = lambda {|x| x.inspect }
+    prc2 = prc.compose(:to_s, :length)
+    assert_equal( 3, prc2[123] )
+    assert_equal( 5, prc2['abc'] )
+  end
+  def test_compose__empty
+    prc = lambda {|x| x }
+    assert_same( prc, prc.compose )
+  end
+  def test_compose__single
+    prc = lambda {|x| x + 1 }
+    prc2 = prc.compose(:abs)
+    assert_equal( 4, prc2[-5] )
+  end
+end
+
+class Test_functional_precompose < Test::Unit::TestCase
+  def test_precompose__readme_example
+    prc = lambda {|x| x.inspect }
+    prc2 = prc.precompose(:to_s, :length)
+    assert_equal( '3', prc2[123] )
+    assert_equal( '3', prc2['abc'] )
+  end
+  def test_precompose__empty
+    prc = lambda {|x| x }
+    assert_same( prc, prc.precompose )
+  end
+  def test_precompose__single
+    prc = lambda {|x| x * 2 }
+    prc2 = prc.precompose(:to_i)
+    assert_equal( 246, prc2['123'] )
+  end
+end
+
+class Test_functional_mapply < Test::Unit::TestCase
+  def test_mapply__basic
+    prc = lambda {|x| x.to_s }
+    assert_equal( ['1', '2', '3'], prc.mapply(1, 2, 3) )
+  end
+  def test_mapply__equivalent_to_map
+    prc = lambda {|x| x * 2 }
+    args = [1, 2, 3, 4]
+    assert_equal( args.map(&prc), prc.mapply(*args) )
+  end
+  def test_mapply__empty
+    prc = lambda {|x| x }
+    assert_equal( [], prc.mapply )
+  end
+end
+
+class Test_functional_memoize < Test::Unit::TestCase
+  def test_memoize__caches_result
+    call_count = 0
+    prc = lambda do |x|
+      call_count += 1
+      x * 2
+    end
+    memo = prc.memoize
+    assert_equal( 4, memo.call(2) )
+    assert_equal( 1, call_count )
+    assert_equal( 4, memo.call(2) )
+    assert_equal( 1, call_count )
+  end
+  def test_memoize__different_args
+    call_count = 0
+    prc = lambda do |x|
+      call_count += 1
+      x * 2
+    end
+    memo = prc.memoize
+    assert_equal( 4, memo.call(2) )
+    assert_equal( 6, memo.call(3) )
+    assert_equal( 2, call_count )
+  end
+  def test_memoise__alias
+    prc = lambda {|x| x }
+    assert_equal( prc.method(:memoize), prc.method(:memoise) )
+  end
+end
+
+class Test_functional_trans < Test::Unit::TestCase
+  def test_trans__reorder
+    prc = lambda {|a, b, c| [a, b, c] }
+    prc2 = prc.trans(2, 0, 1)
+    assert_equal( [:c, :a, :b], prc2.call(:a, :b, :c) )
+  end
+  def test_trans__duplicate_index
+    prc = lambda {|a, b| [a, b] }
+    prc2 = prc.trans(0, 0)
+    assert_equal( [:x, :x], prc2.call(:x, :y) )
+  end
+  def test_trans__capped_by_args
+    prc = lambda {|*a| a }
+    prc2 = prc.trans(2, 1, 0)
+    assert_equal( [nil, :b], prc2.call(:a, :b) )
+  end
+  def test_trans__capped_by_indices
+    prc = lambda {|*a| a }
+    prc2 = prc.trans(1, 0)
+    assert_equal( [:b, :a], prc2.call(:a, :b, :c) )
+  end
+  # arity: :min (default, same as above tests)
+  def test_trans__arity_min_explicit
+    prc = lambda {|*a| a }
+    prc2 = prc.trans(1, 0, arity: :min)
+    assert_equal( [:b, :a], prc2.call(:a, :b, :c) )
+  end
+  # arity: :indices
+  def test_trans__arity_indices__args_short
+    prc = lambda {|*a| a }
+    prc2 = prc.trans(2, 0, 1, arity: :indices)
+    assert_equal( [nil, :a, :b], prc2.call(:a, :b) )
+  end
+  def test_trans__arity_indices__args_long
+    prc = lambda {|*a| a }
+    prc2 = prc.trans(1, 0, arity: :indices)
+    assert_equal( [:b, :a], prc2.call(:a, :b, :c) )
+  end
+  # arity: :arguments
+  def test_trans__arity_arguments__args_short
+    prc = lambda {|*a| a }
+    prc2 = prc.trans(2, 0, 1, arity: :arguments)
+    assert_equal( [nil, :a], prc2.call(:a, :b) )
+  end
+  def test_trans__arity_arguments__args_long
+    prc = lambda {|*a| a }
+    prc2 = prc.trans(1, 0, arity: :arguments)
+    assert_equal( [:b, :a, :c], prc2.call(:a, :b, :c) )
+  end
+  # arity: :max
+  def test_trans__arity_max__args_short
+    prc = lambda {|*a| a }
+    prc2 = prc.trans(2, 0, 1, arity: :max)
+    assert_equal( [nil, :a, :b], prc2.call(:a, :b) )
+  end
+  def test_trans__arity_max__args_long
+    prc = lambda {|*a| a }
+    prc2 = prc.trans(1, 0, arity: :max)
+    assert_equal( [:b, :a, :c], prc2.call(:a, :b, :c) )
+  end
+  def test_trans__arity_max__equal_length
+    prc = lambda {|*a| a }
+    prc2 = prc.trans(2, 0, 1, arity: :max)
+    assert_equal( [:c, :a, :b], prc2.call(:a, :b, :c) )
+  end
+  # invalid arity
+  def test_trans__arity_invalid
+    prc = lambda {|*a| a }
+    assert_raise( ArgumentError ) { prc.trans(0, 1, arity: :bogus) }
+  end
+end
+
+class Test_functional_zipmap < Test::Unit::TestCase
+  def test_zipmap__readme_example
+    printer = lambda {|*x| x }
+    mapped = printer.zipmap(:upcase, :downcase, :to_sym)
+    assert_equal( ['HELLO', 'there', :Everyone], mapped.call('Hello', 'There', 'Everyone') )
+  end
+  def test_zipmap__nil_passthrough
+    prc = lambda {|a, b| [a, b] }
+    prc2 = prc.zipmap(nil, :to_s)
+    assert_equal( [42, '42'], prc2.call(42, 42) )
+  end
+  def test_zipmap__callable
+    doubler = lambda {|x| x * 2 }
+    prc = lambda {|a, b| [a, b] }
+    prc2 = prc.zipmap(doubler, nil)
+    assert_equal( [10, 5], prc2.call(5, 5) )
+  end
+  def test_zipmap__type_error
+    prc = lambda {|a| a }
+    prc2 = prc.zipmap(123)
+    assert_raise( TypeError ) { prc2.call('x') }
+  end
+end
+
+class Test_functional_juxt < Test::Unit::TestCase
+  def test_juxt__readme_example
+    func = Proc.juxt :upcase, :downcase, :length
+    assert_equal( ['ABC', 'abc', 3], func.call('AbC') )
+  end
+  def test_juxt__with_procs
+    doubler = lambda {|x| x * 2 }
+    negator = lambda {|x| -x }
+    func = Proc.juxt(doubler, negator)
+    assert_equal( [10, -5], func.call(5) )
+  end
+end
+
+class Test_functional_identity < Test::Unit::TestCase
+  def test_identity__returns_same_object
+    func = Proc.identity
+    obj = Object.new
+    assert_same( obj, func.call(obj) )
+  end
+  def test_identity__with_values
+    func = Proc.identity
+    assert_equal( 42, func.call(42) )
+    assert_equal( 'hello', func.call('hello') )
+    assert_nil( func.call(nil) )
+  end
+end
+
+class Test_functional_const < Test::Unit::TestCase
+  def test_const__returns_constant
+    obj = Object.new
+    func = Proc.const(obj)
+    assert_same( obj, func.call )
+    assert_same( obj, func.call(1, 2, 3) )
+  end
+  def test_const__same_object_mutations_stick
+    ary = [1, 2, 3]
+    func = Proc.const(ary)
+    func.call.push(4)
+    assert_equal( [1, 2, 3, 4], func.call )
+  end
+end
+
+class Test_functional_unfold < Test::Unit::TestCase
+  def test_unfold__counting
+    enum = Enumerator.unfold(1) {|n| [n, n + 1] }
+    assert_equal( [1, 2, 3, 4, 5], enum.take(5) )
+  end
+  def test_unfold__fibonacci
+    enum = Enumerator.unfold([0, 1]) {|(a, b)| [a, [b, a + b]] }
+    assert_equal( [0, 1, 1, 2, 3], enum.take(5) )
+  end
+  def test_unfold__termination
+    enum = Enumerator.unfold(1) {|n| n <= 3 ? [n, n + 1] : nil }
+    assert_equal( [1, 2, 3], enum.to_a )
+  end
+  def test_unfold__no_block
+    assert_raise( ArgumentError ) { Enumerator.unfold(1) }
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mug
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.1.0
 platform: ruby
 authors:
 - Matthew Kerwin
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-04-22 00:00:00.000000000 Z
+date: 2026-05-01 00:00:00.000000000 Z
 dependencies: []
 description: |
   == MUG: Matty's Ultimate Gem
@@ -45,6 +45,7 @@ files:
 - lib/mug/enumerable/counts.rb
 - lib/mug/enumerable/hash-like.rb
 - lib/mug/fragile-method-chain.rb
+- lib/mug/functional.rb
 - lib/mug/hash.rb
 - lib/mug/hash/fetch-assign.rb
 - lib/mug/hash/map.rb
@@ -92,6 +93,7 @@ files:
 - test/test-enumerable-chain.rb
 - test/test-enumerable-hash-like.rb
 - test/test-fragile-method-chain.rb
+- test/test-functional.rb
 - test/test-hashfetchassign.rb
 - test/test-hashmap.rb
 - test/test-hashmerge.rb
@@ -157,6 +159,7 @@ test_files:
 - test/test-enumerable-chain.rb
 - test/test-enumerable-hash-like.rb
 - test/test-fragile-method-chain.rb
+- test/test-functional.rb
 - test/test-hashfetchassign.rb
 - test/test-hashmap.rb
 - test/test-hashmerge.rb