ex_aequo_base 0.1.16 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2bcb8cf68f1e277f44cb2f376b5f49a1e4683a02b136e9dd15a07a993d4ddf33
-  data.tar.gz: 35848bf635324d4756242bc20cdad347d13566df3c5a61d56a9640e068a4de23
+  metadata.gz: b07e39f7fa5cfc7d8dbd8db59b023f831ec214e3d281bc55f5430afb815c9028
+  data.tar.gz: 2fe81797ea2ed2a385dda8b8637aa8618ee2a4ff75fff224120d7cc09f0b6038
 SHA512:
-  metadata.gz: 92e30c26cf1037714ba1139418b6e8e0a5ac40f5a3db9f17d114330d8ae736ba4be875c09f2a2357aae3ece8d28fbcb67c1c773af2d3a9a502fc96364701a097
-  data.tar.gz: 9e5d71d974b20eda0572cda76332b916a8cc69a4f1b25de3fc625d8725f4841a99db1c5199d3eafe9e1c60e84da9f5f9fe7680b0a3959ec5dd5781f488a335f2
+  metadata.gz: e011a5f3f439d0e2b8881885f6ac9bba59a7bdd8d7f0f65be791d24d3632ad644fb5d52b7c9addaa7ac57aab145cf08da2dd7ddc2aec72b4f25e9fbe81fe7773
+  data.tar.gz: c9ee6f3e9bb090efe94a8d17bdf82d1f5b97255376c542d57c2ac306efc4d52b4615abcb5ba3b77fd61c327134c82158e8e0d293b36a04b32d8e81edc1874b94

data/lib/ex_aequo/base/all.rb

@@ -3,11 +3,13 @@ require_relative 'colorize'
 require_relative 'enumerable'
 require_relative 'fn'
 require_relative 'forwarder'
+require_relative 'function'
 require_relative 'kernel'
 require_relative 'import_none'
 require_relative 'open_struct'
 require_relative 'regexp'
 require_relative 'string'
+require_relative 'to_proc'
 # require_relative 'match_data'
 # Colorize = ExAequo::Base::Colorize
 # SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/ex_aequo/base/fn/curry.rb

@@ -6,7 +6,7 @@ module ExAequo
   module Base
     module Fn extend self
       extend Forwarder
-      forward_all :curry, to: Helpers 
+      forward_all :curry_send, :curry, to: Helpers 
     end
   end
 end

data/lib/ex_aequo/base/fn/helpers.rb

@@ -3,52 +3,117 @@
 module ExAequo
   module Base
     module Fn
-      Placeholder = BasicObject.new
+      PlaceholderClass = Class.new(BasicObject)
+      Placeholder = PlaceholderClass.new
 
       module Helpers extend self
-        def curry(rcv, *positionals, **keywords, &blk)
-          return _send_curry(*positionals, **keywords, &blk) if rcv == Placeholder
-
-          _send_to(rcv, *positionals, **keywords, &blk)
+        def curry_send(*positionals, **keywords, &b)
+          -> (*args, **kwds, &blk) do
+            actual = _make_actual_params(positionals, args, keywords, kwds, arity: -1)
+            case actual
+            in {actual_args: [rcv, *actual_args], actual_kwds:, complete: true, **nil}
+              rcv.send(*actual_args, **actual_kwds, &(blk || b))
+            else
+              # This is a kludge to fix the simplecov missing branch _error_
+              actual in {actual_args: [_, *] => actual_args, actual_kwds:, complete: false, **nil}
+              curry_send(*actual_args, **actual_kwds, &(blk || b))
+            end
+          end
         end
 
-        private
-        def _make_actual_params(positionals, args, keywords, kwds, offset:)
-          as = []
-          ks = {}
-          n = 0
+        def curry(*positionals, **keywords, &blk)
+          raise ArgumentError, "#{__method__} needs a block" unless blk
 
-          positionals.each do
-            if it == Placeholder
-              as << args[n]
-              n += 1
+          -> (*args, **kwds, &b) do
+            _make_actual_params(positionals, args, keywords, kwds, arity: blk.arity) => {actual_args:, actual_kwds:, complete:, **nil}
+            if complete
+              blk.(*actual_args, **actual_kwds, &b)
             else
-              as << it
+              raise ArgumentError, "must not provide a block if function is still a partial application" if b
+              curry(*actual_args, **actual_kwds, &blk)
             end
           end
+        end
 
-          keywords.each do |k, v|
-            if v == Placeholder
-              ks[k] = args[n]
-              n += 1
-            end
+        private
+        def _check_for_completeness(actual_args:, actual_kwds:, arity:)
+          if arity < 0
+            _check_for_min_completeness(actual_args:, actual_kwds:, arity: arity.abs.pred)
+          else
+            _check_for_exact_completeness(actual_args:, actual_kwds:, arity:)
           end
-          as += Array(args[positionals.length-offset..])
-          [as, keywords.merge(ks).merge(kwds)]
         end
 
-        def _send_curry(*positionals, **keywords, &b)
-          -> (rcv, *args, **kwds, &blk) do
-            _make_actual_params(positionals, args, keywords, kwds, offset: 1) => actual_pos, actual_kwds
-            rcv.send(*actual_pos, **actual_kwds, &(blk || b))
+        def _check_for_exact_completeness(actual_args:, actual_kwds:, arity:)
+          arity = arity - 1 unless actual_kwds.empty?
+          _check_for_placeholders(actual_args:, actual_kwds:) => {complete:, size:, **nil}
+          raise ArgumentError, "too many arguments arity = #{arity} but #{size} provided" if size > arity
+
+          return {actual_args:, actual_kwds:, complete:} if size == arity
+
+          {
+            actual_args: actual_args + [Placeholder] * (arity - size),
+            actual_kwds:,
+            complete: false
+          }
+        end
+
+        def _check_for_min_completeness(actual_args:, actual_kwds:, arity:)
+          _check_for_placeholders(actual_args:, actual_kwds:) => {complete:, size:, **nil}
+          return {actual_args:, actual_kwds:, complete:} if size >= arity
+
+          {
+            actual_args: actual_args + [Placeholder] * (arity - size),
+            actual_kwds:,
+            complete: false
+          }
+        end
+
+        def _check_for_placeholders(actual_args:, actual_kwds:)
+          size = actual_args.size
+          needed_kwds = actual_kwds.values.count { it == Placeholder }
+          complete = actual_args.none? { it == Placeholder }
+
+          complete &&= needed_kwds.zero?
+          {complete:, size:}
+        end
+
+        def _make_actual_params(curried_args, current_args, curried_kwds, current_kwds, arity:)
+          _make_actual_args(curried_args, current_args) in actual_args, remaining_args
+          _make_actual_kwds(curried_kwds, current_kwds, remaining_args) in actual_kwds, remaining_args
+
+          actual_args += remaining_args
+          actual_kwds = curried_kwds.merge(actual_kwds).merge(current_kwds)
+          _check_for_completeness(actual_args:, actual_kwds:, arity:)
+        end
+
+        def _make_actual_args(curried_args, actual_args)
+          as = []
+          curried_args.each do
+            if actual_args.empty?
+              as << it
+            elsif it == Placeholder
+              as << actual_args.first
+              actual_args = actual_args.drop(1)
+            else
+              as << it
+            end
           end
+          [as, actual_args]
         end
 
-        def _send_to(rcv, *positionals, **keywords, &b)
-          -> (*args, **kwds, &blk) do
-            _make_actual_params(positionals, args, keywords, kwds, offset: 0) => actual_pos, actual_kwds
-            rcv.send(*actual_pos, **actual_kwds, &(blk || b))
+        def _make_actual_kwds(curried_kwds, actual_kwds, remaining_args)
+          ks = {}
+          curried_kwds.each do |k, v|
+            if v == Placeholder
+              case remaining_args
+              in [arg, *remaining_args]
+                ks[k] = arg
+              else
+              end
+            end
           end
+          [ks, remaining_args]
         end
       end
     end

data/lib/ex_aequo/base/fn.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative 'fn/curry'
 require_relative 'to_proc'
 module ExAequo
   module Base
@@ -10,6 +11,11 @@ module ExAequo
         '!' => _not,
       }
 
+      def apply(fn_desc=nil, &blk)
+        fun = mk_fun_or(fn_desc, &blk)
+        -> (args) { fun.(*args) }
+      end
+
       def mk_fun(fn_desc)
         case fn_desc
         in String
@@ -18,10 +24,12 @@ module ExAequo
           -> { it.send(fn_desc) }
         in Array
           -> { it.send(*fn_desc) }
-        in _
+        else
           fn_desc.to_proc
         end
-        # TODO: Allow for other fn_desc then Array and Symbol
+      rescue NoMethodError
+        -> { fn_desc === it }
+        # TODO: Allow for other fn_desc then Array and Symbolk
       end
 
       def mk_fun_or(fn_desc=nil, &blk)

data/lib/ex_aequo/base/function/class_methods.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ExAequo
+  module Base
+    class Function
+      module ClassMethods
+        def curried(*args, **kwds, &blk)
+          new(Fn.curry(*args, **kwds, &blk), level: 3)
+        end
+
+        def sending(*args, **kwds, &blk)
+          new(Fn.curry_send(*args, **kwds, &blk), level: 3)
+        end
+      end
+      extend ClassMethods
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/ex_aequo/base/function/combinator_methods.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ExAequo
+  module Base
+    class Function
+      module CombinatorMethods
+        define_method :> do |other|
+          self.class.new(name: "(#{name} > #{other})") do |*args, **kwds, &blk|
+            other.(self.(*args, **kwds, &blk))
+          end
+        end
+      end
+      include CombinatorMethods 
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/ex_aequo/base/function.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'ex_aequo/base/fn'
+require 'ex_aequo/base/function/class_methods'
+require 'ex_aequo/base/function/combinator_methods'
+module ExAequo
+  module Base
+    class Function
+      attr_reader :arity, :function, :name
+
+      def call(*args, **kwds, &blk)
+        function.(*args, **kwds, &blk)
+      rescue StandardError => e
+        raise(e, e.message + " in #{name}")
+      end
+
+      def named(name)
+        @name = name
+        self
+      end
+
+      def to_proc = function
+
+      def to_s = name
+
+      private
+      def initialize(func_desc=nil, name: nil, level: 1, &blk)
+        raise ArgumentError, "must not provide function description and a blk" if func_desc && blk
+        raise ArgumentError, "must provide either a function description or a blk" unless func_desc || blk
+        @function = blk ? blk : Fn.mk_fun(func_desc)
+        @arity = function.arity
+        @level = level
+        @name = name || _mk_name
+      end
+
+      def _mk_name
+        @name = caller[@level]
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/ex_aequo/base/import_all.rb

@@ -4,6 +4,7 @@ require_relative 'all'
 
 Colorize = ExAequo::Base::Colorize
 Forwarder = ExAequo::Base::Forwarder
+Function = ExAequo::Base::Function
 
 require_relative 'fn/all'
 

data/lib/ex_aequo/base/to_proc/unbound_method.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class UnboundMethod
+  def to_proc
+    ->(rcv, *a, **k, &b) do
+      self.bind(rcv).(*a, **k, &b)
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/ex_aequo/base/version.rb

@@ -2,7 +2,7 @@
 
 module ExAequo
   module Base
-    VERSION = '0.1.16'
+    VERSION = '0.2.0'
   end
 end
 # SPDX-License-Identifier: AGPL-3.0-or-later

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ex_aequo_base
 version: !ruby/object:Gem::Version
-  version: 0.1.16
+  version: 0.2.0
 platform: ruby
 authors:
 - Robert Dober
@@ -62,6 +62,9 @@ files:
 - lib/ex_aequo/base/fn/curry.rb
 - lib/ex_aequo/base/fn/helpers.rb
 - lib/ex_aequo/base/forwarder.rb
+- lib/ex_aequo/base/function.rb
+- lib/ex_aequo/base/function/class_methods.rb
+- lib/ex_aequo/base/function/combinator_methods.rb
 - lib/ex_aequo/base/import_all.rb
 - lib/ex_aequo/base/import_none.rb
 - lib/ex_aequo/base/kernel.rb
@@ -78,6 +81,7 @@ files:
 - lib/ex_aequo/base/to_proc/regexp.rb
 - lib/ex_aequo/base/to_proc/string.rb
 - lib/ex_aequo/base/to_proc/true_class.rb
+- lib/ex_aequo/base/to_proc/unbound_method.rb
 - lib/ex_aequo/base/version.rb
 homepage: https://codeberg.org/lab419/rb_ex_aequo_base
 licenses: