rb-kgy-fp 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1d187603140145361013f2277fb3d89ec9a2a49373a5b1d2d0839e48f9b53f48
+  data.tar.gz: 1eb4b34145b0ac7ce815cd4c4d55e4f82bb10b3469705ff4dd28fcc5e80a00f0
+SHA512:
+  metadata.gz: b4bfb2827314527f15092992d70c25332c703660a85c14f5038a0179667190c0773a9d0341a51ed78491a4119ab3fbc117bf954c2056090874360a128582ff75
+  data.tar.gz: 1ddb718352d5eaf953c21280573b1086a00da7b0d627d46c1130f66f6db995df7985928f2c85f23115ec672b16553421b16c493ecff5554609e0e9e94c49acf6

data/lib/rb-kgy-fp/curry_fun.rb

@@ -0,0 +1,351 @@
+# frozen_string_literal: true
+
+require 'lib/special'
+
+PH = Special::PH
+OPT = Special::OPT
+
+module CurryFun
+  def self.eq?(t, u = PH)
+    if u == PH
+      ->(u) { eq? t, u }
+    else
+      t == u
+    end
+  end
+
+  def self.ne?(t, u = PH)
+    if u == PH
+      ->(u) { ne? t, u }
+    else
+      t != u
+    end
+  end
+
+  def self.gt?(t, u = PH)
+    if u == PH
+      ->(u) { gt? t, u }
+    elsif t.respond_to? :>
+      t > u
+    else
+      (t <=> u) == 1
+    end
+  end
+
+  def self.ge?(t, u = PH)
+    if u == PH
+      ->(u) { ge? t, u }
+    elsif t.respond_to? :>=
+      t >= u
+    else
+      (t <=> u) >= 0
+    end
+  end
+
+  def self.lt?(t, u = PH)
+    if u == PH
+      ->(u) { lt? t, u }
+    elsif t.respond_to? :<
+      t < u
+    else
+      (t <=> u) == -1
+    end
+  end
+
+  def self.le?(t, u = PH)
+    if u == PH
+      ->(u) { le? t, u }
+    elsif t.respond_to? :<=
+      t <= u
+    else
+      (t <=> u) <= 0
+    end
+  end
+
+  def self.const(a, _ = PH)
+    if _ == PH
+      ->(_) { a }
+    else
+      a
+    end
+  end
+
+  def self.pipe(*fns)
+    ->(arg) { fns.reduce(arg) { |acc, fn| fn.(acc) } }
+  end
+
+  def self.compose(*fns)
+    ->(arg) { fns.reverse.reduce(arg) { |acc, fn| fn.(acc) } }
+  end
+
+  def self.not? & fn
+    ->(*args, **kwargs) { !fn.(*args, **kwargs) }
+  end
+
+  def self.nil_or fallback, value = PH
+    if value == PH
+      ->(value) { nil_or fallback, value }
+    else
+      value.nil? ? fallback : value
+    end
+  end
+
+  def self.nil_or_else get_fallback: OPT, value: PH, &blk
+    if (!blk && get_fallback == OPT) || (blk && get_fallback.class == Proc)
+      raise ArgumentError.new "Either get_fallback or blk must be provided"
+    end
+    _fn = blk || get_fallback
+    if value == PH
+      ->(value) { nil_or_else get_fallback: _fn, value: value }
+    else
+      value.nil? ? _fn.() : value
+    end
+  end
+
+  def self.not_nil_or fallback, value = PH
+    if value == PH
+      ->(value) { not_nil_or fallback, value }
+    else
+      value.nil? ? value : fallback
+    end
+  end
+
+  def self.not_nil_or_else get_fallback: OPT, value: PH, &blk
+    if (!blk && get_fallback == OPT) || (blk && get_fallback.class == Proc)
+      raise ArgumentError.new "Either get_fallback or blk must be provided"
+    end
+    _fn = blk || get_fallback
+    if value == PH
+      ->(value) { not_nil_or_else get_fallback: _fn, value: value }
+    else
+      value.nil? ? value : _fn.()
+    end
+  end
+
+  def self.not_nil_map mapper: OPT, value: PH, &blk
+    if (!blk && mapper == OPT) || (blk && (mapper.class == Proc || mapper.class == Symbol))
+      raise ArgumentError.new "Either mapper or blk must be provided"
+    end
+    _fn = blk || (mapper.class == Proc ? mapper : ->(obj) { obj.method(mapper).() })
+    if value == PH
+      ->(value) { not_nil_map mapper: _fn, value: value }
+    else
+      value.nil? ? value : _fn.(value)
+    end
+  end
+
+  def self.add a, b = PH
+    if b == PH
+      ->(b) { add a, b }
+    else
+      a + b
+    end
+  end
+
+  def self.minus a, b = PH
+    if b == PH
+      ->(b) { minus a, b }
+    else
+      a - b
+    end
+  end
+
+  def self.mul a, b = PH
+    if b == PH
+      ->(b) { mul a, b }
+    else
+      a * b
+    end
+  end
+
+  def self.div a, b = PH
+    if b == PH
+      ->(b) { div a, b }
+    else
+      a / b
+    end
+  end
+
+  def self.mod a, b = PH
+    if b == PH
+      ->(b) { mod a, b }
+    else
+      a % b
+    end
+  end
+
+  def self.flip a, b = PH, &fn
+    if b == PH && !fn
+      ->(b = PH, &fn) { flip(a, b, &fn) }
+    elsif b == PH && fn
+      ->(b) { flip(a, b, &fn) }
+    elsif b != PH && !fn
+      ->(&fn) { flip(a, b, &fn) }
+    else
+      fn.(b, a)
+    end
+  end
+
+  def self.all? fn: OPT, args: PH, &blk
+    if (fn == OPT && !blk) || ((fn.class == Proc || fn.class == Symbol) && blk)
+      raise ArgumentError.new("Either fn or blk must be provided")
+    end
+    _fn = blk || (fn.class == Proc ? fn : ->(obj) { obj.method(fn).() })
+    if args == PH
+      ->(*args) { all?(fn: _fn, args: args) }
+    else
+      args.reduce(true) { |result, arg| result && _fn.(arg) }
+    end
+  end
+
+  def self.any? fn: OPT, args: PH, &blk
+    if (fn == OPT && !blk) || ((fn.class == Proc || fn.class == Symbol) && blk)
+      raise ArgumentError.new("Either fn or blk must be provided")
+    end
+    _fn = blk || (fn.class == Proc ? fn : ->(obj) { obj.method(fn).() })
+    if args == PH
+      ->(*args) { any?(fn: _fn, args: args) }
+    else
+      args.reduce(false) { |result, arg| result || _fn.(arg) }
+    end
+  end
+
+  def self.and? a, b = PH
+    if b == PH
+      ->(b) { and?(a, b) }
+    else
+      a && b
+    end
+  end
+
+  def self.or? a, b = PH
+    if b == PH
+      ->(b) { or?(a, b) }
+    else
+      a || b
+    end
+  end
+
+  def self.xor? a, b = PH
+    if b == PH
+      ->(b) { xor? a, b }
+    else
+      (!a && b) || (a && !b)
+    end
+  end
+
+  def self.clamp lower, upper = PH, value = PH
+    if upper == PH
+      ->(upper = PH, value = PH) { clamp lower, upper, value }
+    elsif value == PH
+      ->(value) { clamp lower, upper, value }
+    else
+      if lower > value
+        lower
+      elsif upper < value
+        upper
+      else
+        value
+      end
+    end
+  end
+
+  def self.cond cond_mappers
+    -> (*args, **kwargs) {
+      return nil if args.length == 0 && kwargs.size == 0
+      cond_mappers.each do |fns|
+        fns => [cond, mapper]
+        return mapper.(*args, **kwargs) if cond.(*args, **kwargs)
+      end
+      nil
+    }
+  end
+
+  def self.desc(&comparator)
+    -> (values) {
+      if values.class == Hash
+        Hash[values.sort_by { |k, v| comparator.(k, v) }.reverse]
+      elsif values.class == Array
+        values.sort_by { |v| comparator.(v) }.reverse
+      end
+    }
+  end
+
+  def self.asc(&comparator)
+    -> (values) {
+      if values.class == Hash
+        Hash[values.sort_by { |k, v| comparator.(k, v) }]
+      elsif values.class == Array
+        values.sort_by { |v| comparator.(v) }
+      end
+    }
+  end
+
+  def self.diff obj1, obj2 = PH
+    if obj2 == PH
+      ->(obj2) { diff obj1, obj2 }
+    else
+      get_diff = ->(arr1, arr2) {
+        arr1.size > arr2.size ? arr1 - arr2 : arr2 - arr1
+      }
+      if obj1.class != obj2.class
+        raise ArgumentError.new "obj1 is not same type with obj2"
+      elsif obj1.class == Hash
+        diff = get_diff.(obj1.to_a, obj2.to_a)
+        Hash[*diff.flatten]
+      else
+        get_diff.(obj1, obj2)
+      end
+    end
+  end
+
+  def self.intersect obj1, obj2 = PH
+    if obj2 == PH
+      ->(obj2) { intersect obj1, obj2 }
+    else
+      get_inte = ->(arr1, arr2) {
+        arr1.size > arr2.size ? arr1 - (arr1 - arr2) : arr2 - (arr2 - arr1)
+      }
+      if obj1.class != obj2.class
+        raise ArgumentError.new "obj1 is not same type with obj2"
+      elsif obj1.class == Hash
+        inte = get_inte.(obj1.to_a, obj2.to_a)
+        Hash[*inte.flatten]
+      else
+        get_inte.(obj1, obj2)
+      end
+    end
+  end
+
+  def self.non_intersect obj1, obj2 = PH
+    if obj2 == PH
+      ->(obj2) { non_intersect obj1, obj2 }
+    else
+      if obj1.class != obj2.class
+        raise ArgumentError.new "obj1 is not same type with obj2"
+      elsif obj1.class == Hash
+        left = obj1.to_a - obj2.to_a
+        right = obj2.to_a - obj1.to_a
+        Hash[*left.flatten, *right.flatten]
+      else
+        left = obj1 - obj2
+        right = obj2 - obj1
+        (left + right).uniq
+      end
+    end
+  end
+
+  def self.union obj1, obj2 = PH
+    if obj2 == PH
+      ->(obj2) { union obj1, obj2 }
+    else
+      if obj1.class != obj2.class
+        raise ArgumentError.new "obj1 is not same type with obj2"
+      elsif obj1.class == Hash
+        obj1.merge(obj2)
+      else
+        (obj1 + obj2).uniq
+      end
+    end
+  end
+end

data/lib/rb-kgy-fp/fun.rb

@@ -0,0 +1,378 @@
+# frozen_string_literal: true
+
+module Fun
+  def self.eq?(a, b)
+    a == b
+  end
+
+  def self.ne?(a, b)
+    a != b
+  end
+
+  def self.gt?(a, b)
+    if a.respond_to?(:>)
+      a > b
+    else
+      (a <=> b) == 1
+    end
+  end
+
+  def self.ge?(a, b)
+    if a.respond_to?(:>=)
+      a >= b
+    else
+      (a <=> b) >= 0
+    end
+  end
+
+  def self.lt?(a, b)
+    if a.respond_to?(:<)
+      a < b
+    else
+      (a <=> b) == -1
+    end
+  end
+
+  def self.le?(a, b)
+    if a.respond_to?(:<=)
+      a <= b
+    else
+      (a <=> b) <= 0
+    end
+  end
+
+  def self.id t
+    t
+  end
+
+  def self.const(a, _)
+    a
+  end
+
+  def self.pipe(arg, *fns)
+    fns.reduce(arg) { |acc, fn| fn.(acc) }
+  end
+
+  def self.compose(arg, *fns)
+    fns.reverse.reduce(arg) { |acc, fn| fn.(acc) }
+  end
+
+  def self.not?(fn, *args, **kwargs)
+    !fn.(*args, **kwargs)
+  end
+
+  def self.nil_or(value, fallback)
+    value.nil? ? fallback : value
+  end
+
+  def self.nil_or_else(value, &get_fallback)
+    if value.nil?
+      get_fallback.()
+    else
+      value
+    end
+  end
+
+  def self.not_nil_or(value, fallback)
+    if !value.nil?
+      fallback
+    else
+      value
+    end
+  end
+
+  def self.not_nil_or_else(value, &get_fallback)
+    if !value.nil?
+      get_fallback.()
+    else
+      value
+    end
+  end
+
+  def self.not_nil_map(value, &mapper)
+    value.nil? ? value : mapper.(value)
+  end
+
+  def self.add(a, b)
+    a + b
+  end
+
+  def self.minus(a, b)
+    a - b
+  end
+
+  def self.mul(a, b)
+    a * b
+  end
+
+  def self.div(a, b)
+    a / b
+  end
+
+  def self.mod(a, b)
+    a % b
+  end
+
+  def self.flip(b, a, &fn)
+    fn.(a, b)
+  end
+
+  def self.all?(fst, *snd)
+    if fst.class == Proc
+      snd.all?(&fst)
+    else
+      snd.reduce(true) { |result, fn| result && fn.(fst) }
+    end
+  end
+
+  def self.any?(fst, *snd)
+    if fst.class == Proc
+      snd.all?(&fst)
+    else
+      snd.reduce(false) { |result, fn| result || fn.(fst) }
+    end
+  end
+
+  def self.clamp(lower, upper, value)
+    if lower > value
+      lower
+    elsif upper < value
+      upper
+    else
+      value
+    end
+  end
+
+  def self.cond(cond_mappers, *args, **kwargs)
+    return nil if args.length == 0 && kwargs.size == 0
+    cond_mappers.each { |fns|
+      fns => [cond, mapper]
+      return mapper.(*args, **kwargs) if cond.(*args, **kwargs)
+    }
+    nil
+  end
+
+  def self.curry(&fn)
+    require "special"
+
+    req = 1 << 0
+    opt = 1 << 1
+    rest = 1 << 2
+    kreq = 1 << 3
+    kopt = 1 << 4
+    krest = 1 << 5
+    block = 1 << 6
+
+    core = ->(this, fn, c_params = [], c_remain_param_count = 0) do
+      ->(*args, **kwargs, &proc) do
+        cp_c_params = Marshal.load(Marshal.dump(c_params)) # use serialization to ensure whole operation is pure
+        cp_c_remain_param_count = c_remain_param_count
+        arg_idx = 0
+        _kwargs = { **kwargs }
+
+        (0...cp_c_params.length).each { |i|
+          param = cp_c_params[i]
+          filled = param[:value] != Special::PH && param[:value] != Special::OPT
+
+          if (param[:type] & (req | opt)) != 0 && !filled
+            param[:value] = args[arg_idx]
+            arg_idx += 1
+            cp_c_remain_param_count -= 1 if param[:type] == req
+          end
+
+          if (param[:type] & (kreq | kopt) != 0) && !filled && _kwargs[param[:name]] != nil
+            param[:value] = _kwargs.delete(param[:name])
+            cp_c_remain_param_count -= 1 if param[:type] == kreq
+          end
+
+          if param[:type] == block && !filled && proc
+            param[:value] = proc
+            cp_c_remain_param_count -= 1
+          end
+        }
+
+        if args.length >= arg_idx + 1 && cp_c_params.any? { |p| p[:type] == rest }
+          cp_c_params.find { |p| p[:type] == rest }[:value] = args[arg_idx, args.length]
+        end
+
+        if _kwargs.length > 0 && cp_c_params.any? { |p| p[:type] == krest }
+          cp_c_params.find { |p| p[:type] == krest }[:value] = _kwargs
+        end
+
+        if cp_c_remain_param_count == 0
+          _params = []
+          _kparams = {}
+          _proc = nil
+          cp_c_params.each do |param|
+            case param[:type]
+            when req, opt
+              _params << param[:value] if param[:value] != Special::OPT && param[:value] != Special::PH
+            when kreq, kopt
+              _kparams[param[:name]] = param[:value] if param[:value] != Special::OPT && param[:value] != Special::PH
+            when rest
+              _params.push(*param[:value])
+            when krest
+              _kparams.update(param[:value])
+            when proc
+              _proc = param[:value]
+            end
+          end
+          if _proc
+            fn.(*_params, **_kparams, &_proc)
+          else
+            fn.(*_params, **_kparams)
+          end
+        else
+          this.(this, fn, cp_c_params, cp_c_remain_param_count)
+        end
+      end
+    end
+
+    params = []
+    remain_param_count = 0
+
+    # check params
+    fn.parameters.each do |detail|
+      detail => [type, name]
+      case type
+      when :req
+        params << { name: name, value: Special::PH, type: req }
+        remain_param_count += 1
+      when :opt
+        params << { name: name, value: Special::OPT, type: opt }
+      when :rest
+        params << { name: name, type: rest }
+      when :keyreq
+        params << { name: name, value: Special::PH, type: kreq }
+        remain_param_count += 1
+      when :key
+        params << { name: name, value: Special::OPT, type: kopt }
+      when :keyrest
+        params << { name: name, type: krest }
+      when :block
+        params << { name: name, value: Special::PH, type: block }
+        remain_param_count += 1
+      end
+    end
+
+    core.(core, fn, params, remain_param_count)
+  end
+
+  def self.dec n
+    n - 1
+  end
+
+  def self.inc n
+    n + 1
+  end
+
+  def self.desc(values, &comparator)
+    if values.class == Hash
+      Hash[values.sort_by { |k, v| comparator.(k, v) }.reverse]
+    elsif values.class == Array
+      values.sort_by { |v| comparator.(v) }.reverse
+    end
+  end
+
+  def self.asc(values, &comparator)
+    if values.class == Hash
+      Hash[values.sort_by { |k, v| comparator.(k, v) }]
+    elsif values.class == Array
+      values.sort_by { |v| comparator.(v) }
+    end
+  end
+
+  def self.to_sym s
+    s.to_sym
+  end
+
+  def self.diff(obj1, obj2)
+    get_diff = ->(arr1, arr2) {
+      arr1.size > arr2.size ? arr1 - arr2 : arr2 - arr1
+    }
+    if obj1.class != obj2.class
+      raise ArgumentError.new "obj1 is not same type with obj2"
+    elsif obj1.class == Hash
+      diff = get_diff.(obj1.to_a, obj2.to_a)
+      Hash[*diff.flatten]
+    else
+      get_diff.(obj1, obj2)
+    end
+  end
+
+  def self.intersect(obj1, obj2)
+    get_inte = ->(arr1, arr2) {
+      arr1.size > arr2.size ? arr1 - (arr1 - arr2) : arr2 - (arr2 - arr1)
+    }
+    if obj1.class != obj2.class
+      raise ArgumentError.new "obj1 is not same type with obj2"
+    elsif obj1.class == Hash
+      inte = get_inte.(obj1.to_a, obj2.to_a)
+      Hash[*inte.flatten]
+    else
+      get_inte.(obj1, obj2)
+    end
+  end
+
+  def self.non_intersect(obj1, obj2)
+    if obj1.class != obj2.class
+      raise ArgumentError.new "obj1 is not same type with obj2"
+    elsif obj1.class == Hash
+      left = obj1.to_a - obj2.to_a
+      right = obj2.to_a - obj1.to_a
+      Hash[*left.flatten, *right.flatten]
+    else
+      left = obj1 - obj2
+      right = obj2 - obj1
+      (left + right).uniq
+    end
+  end
+
+  def self.union(obj1, obj2)
+    if obj1.class != obj2.class
+      raise ArgumentError.new "obj1 is not same type with obj2"
+    elsif obj1.class == Hash
+      obj1.merge(obj2)
+    else
+      (obj1 + obj2).uniq
+    end
+  end
+
+  def self.empty obj
+    case obj.class.to_s
+    when 'Hash'
+      {}
+    when 'Array'
+      []
+    when 'String'
+      ''
+    else
+      nil
+    end
+  end
+
+  def self.mean * ns
+    ns.reduce(:+) / ns.length
+  end
+
+  def self.median * ns
+    ns.sort[(ns.length / 2).floor]
+  end
+
+  def self.memorize_with(get_key, &action)
+    cache = {}
+    ->(*args, **kwargs) do
+      key = get_key.(*args, **kwargs).to_sym
+      cache[key] = action.(*args, **kwargs) unless cache[key]
+      cache[key]
+    end
+  end
+
+  def self.negate n
+    -n
+  end
+
+  def self.xor? a, b
+    (a && !b) || (!a && b)
+  end
+end