invokable 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f4908866aac724a3af3d142852f6412f3cc93ee7ab8c85f2dd856b08f0039c6c
-  data.tar.gz: bf5f3d83df9c69f5357eacef3bdc2ecc44384852124f4fc012fa6d3e14716cd5
+  metadata.gz: b8be1208734fdbbf1e11e1974834bfb6a65e294c7814a7df1f65775b4a898ae9
+  data.tar.gz: 2693e344b7eb7c1e9e12615c1c6831b6c842219adf39e70aa924bbd65c7edaee
 SHA512:
-  metadata.gz: f71bcec50cf1e9d0049259803eae9d5b19e102f78f14fe0854d5e2c238c3b7679552d64bb66608305c497379418f717fa29a0fe1d921c835c3397a58b37d5a47
-  data.tar.gz: 23827b487b5bb767871585d3bb641f53e8aaa4f28c1e4ef1934e93f200b7665a4a62a34f855767a7bc5424fa472ca62854021e4726b05c0901618ca119a3030c
+  metadata.gz: 2bc791de5268235f8f7f2715e14f7d14bd6d6155f38aafa85f5a976e037a81b0df57e03def253fb9d55d3881e9845db243a6fffc723cc306d2536b0daa15c931
+  data.tar.gz: e36ab920d191d24022954f4cd4d055db571390a7e7e0252a8ad38b456283b344678d534bebf58cbe96b0653af2c10e745ca96de0969a10d8371da4b54c361d48

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    invokable (0.3.0)
+    invokable (0.4.0)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -47,18 +47,34 @@ Objects are functions! Treat any Object, Hashes, Arrays, and Sets as Procs (like
 Use as much or a little as you need:
 
 ```ruby
-require 'invokable'       # loads Invokable module
-require 'invokable/hash'  # loads hash patch
-require 'invokable/array' # loads array patch
-require 'invokable/set'   # loads set patch
-require 'invokable/data'  # loads all patches
+require 'invokable'         # loads Invokable module
+require 'invokable/hash'    # loads hash patch
+require 'invokable/array'   # loads array patch
+require 'invokable/set'     # loads set patch
+require 'invokable/data'    # loads hash, array, and set patches
 ```
 
 ## Why?
 
 A function is a mapping of one value to another with the additional constraint that for the one input value you will
 always get the same output value. So, conceptually, Ruby Hashes, Arrays, and Sets are all functions. Also, there are
-many one method objects out there (e.g. ServiceObjects) that are essentially functions. Why not treat them as such?
+many one method objects out there (e.g. Service Objects) that are essentially functions. Why not treat them as such?
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'invokable'
+```
+
+And then execute:
+
+    > bundle
+
+Or install it yourself as:
+
+    > gem install invokable
 
 ## API
 
@@ -85,21 +101,13 @@ Returns a curried proc. If the `arity` is given, it determines the number of arg
 
 Returns a memoized proc, that is, a proc that caches it return values by it's arguments.
 
-## Installation
-
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'invokable'
-```
-
-And then execute:
+### `<<(invokable) => Proc`
 
-    > bundle
+Returns a proc that is a composition of this invokable and the given invokable.
 
-Or install it yourself as:
+### `>>(invokable) => Proc`
 
-    > gem install invokable
+Returns a proc that is a composition of this invokable and the given invokable.
 
 ## See Also
 

data/lib/invokable.rb

@@ -1,40 +1,15 @@
 require 'invokable/version'
+require 'invokable/core'
+require 'invokable/compose'
 
-module Invokable
-  # If object responds to `call` convert into a Proc forwards it's arguments along to `call`.
-  #
-  # @see https://ruby-doc.org/core-2.7.0/Proc.html#method-i-call Proc#call
-  # @return [Proc]
-  def to_proc
-    if respond_to?(:call)
-      # TODO: Would method(:call) be more performant? We need benchmarks.
-      Proc.new do |*args|
-        call(*args)
-      end
-    else
-      raise "Don't know how to convert #{self.inspect} into a Proc"
-    end
-  end
-
-  # Return a curried proc. If the optional `arity` argument is given, it determines the number of arguments.
-  # A curried proc receives some arguments. 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.
-  #
-  # @see https://ruby-doc.org/core-2.7.0/Proc.html#method-i-curry Proc#curry
-  # @param arity [Number]
-  # @return [Proc]
-  def curry(arity = nil)
-    to_proc.curry(arity)
-  end
+if RUBY_VERSION.split('.').take(2).join('.').to_f < 2.6
+  require 'invokable/proc'
+  require 'invokable/method'
+end
 
-  # Return a memoized proc, that is, a proc that caches it's return values by it's arguments.
-  #
-  # @return [Proc]
-  def memoize
-    Proc.new do |*args|
-      @memo ||= {}
-      @memo[args.hash] ||= call(*args)
-    end
+module Invokable
+  def self.included(base)
+    base.include(Invokable::Core)
+    base.include(Invokable::Compose)
   end
 end

data/lib/invokable/array.rb

@@ -1,10 +1,10 @@
-require_relative '../invokable'
+require_relative 'core'
 
 # Extend core Array object by aliasing it's `[]` method as `call`,
 # and including the `Invokable` module.
 #
 # @see https://ruby-doc.org/core-2.7.0/Array.html#method-i-5B-5D Array#[]
 class Array
-  include Invokable
+  include Invokable::Core
   alias call []
 end

data/lib/invokable/compose.rb

@@ -0,0 +1,25 @@
+module Invokable
+  module Compose
+    # Return a proc that is the composition of this invokable and the given `invokable`.
+    # The returned proc takes a variable number of arguments, calls `invokable` with
+    # them then calls this proc with the result.
+    #
+    # @return [Proc]
+    def <<(invokable)
+      Proc.new do |*args|
+        call(invokable.call(*args))
+      end
+    end
+
+    # Return a proc that is the composition of this invokable and the given `invokable`.
+    # The returned proc takes a variable number of arguments, calls `invokable` with
+    # them then calls this proc with the result.
+    #
+    # @return [Proc]
+    def >>(invokable)
+      Proc.new do |*args|
+        invokable.call(call(*args))
+      end
+    end
+  end
+end

data/lib/invokable/core.rb

@@ -0,0 +1,40 @@
+module Invokable
+  module Core
+    # If object responds to `call` convert into a Proc forwards it's arguments along to `call`.
+    #
+    # @see https://ruby-doc.org/core-2.7.0/Proc.html#method-i-call Proc#call
+    # @return [Proc]
+    def to_proc
+      if respond_to?(:call)
+        # TODO: Would method(:call) be more performant? We need benchmarks.
+        Proc.new do |*args|
+          call(*args)
+        end
+      else
+        raise "Don't know how to convert #{self.inspect} into a Proc"
+      end
+    end
+  
+    # Return a curried proc. If the optional `arity` argument is given, it determines the number of arguments.
+    # A curried proc receives some arguments. 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.
+    #
+    # @see https://ruby-doc.org/core-2.7.0/Proc.html#method-i-curry Proc#curry
+    # @param arity [Integer]
+    # @return [Proc]
+    def curry(arity = nil)
+      to_proc.curry(arity)
+    end
+  
+    # Return a memoized proc, that is, a proc that caches it's return values by it's arguments.
+    #
+    # @return [Proc]
+    def memoize
+      Proc.new do |*args|
+        @memo ||= {}
+        @memo[args.hash] ||= call(*args)
+      end
+    end
+  end
+end

data/lib/invokable/data.rb

@@ -1,4 +1,4 @@
-require_relative '../invokable'
+require_relative 'core'
 require_relative 'hash'
 require_relative 'set'
 require_relative 'array'

data/lib/invokable/hash.rb

@@ -1,10 +1,12 @@
-require_relative '../invokable'
+require_relative 'core'
 
 # Extend core Hash object by aliasing it's `dig` method as `call`,
 # and including the `Invokable` module.
 #
 # @see https://ruby-doc.org/core-2.7.0/Hash.html#method-i-dig Hash#dig
 class Hash
-  include Invokable
-  alias call dig
+  if RUBY_VERSION.split('.').take(2).join('.').to_f < 2.7
+    include Invokable::Core
+    alias call dig
+  end
 end

data/lib/invokable/method.rb

@@ -0,0 +1,5 @@
+require_relative 'compose'
+
+class Method
+  include Invokable::Compose
+end

data/lib/invokable/proc.rb

@@ -0,0 +1,5 @@
+require_relative 'compose'
+
+class Proc
+  include Invokable::Compose
+end

data/lib/invokable/set.rb

@@ -1,11 +1,11 @@
 require 'set'
-require_relative '../invokable'
+require_relative 'core'
 
 # Extend stdlib Set object by aliasing it's `include?` method as `call`,
 # and including the `Invokable` module.
 #
 # @see https://ruby-doc.org/stdlib-2.7.0/libdoc/set/rdoc/Set.html#method-i-include-3F Set#include?
 class Set
-  include Invokable
+  include Invokable::Core
   alias call include?
 end

data/lib/invokable/version.rb

@@ -1,3 +1,3 @@
 module Invokable
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: invokable
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Delon Newman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-10 00:00:00.000000000 Z
+date: 2020-02-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -71,8 +71,12 @@ files:
 - invokable.gemspec
 - lib/invokable.rb
 - lib/invokable/array.rb
+- lib/invokable/compose.rb
+- lib/invokable/core.rb
 - lib/invokable/data.rb
 - lib/invokable/hash.rb
+- lib/invokable/method.rb
+- lib/invokable/proc.rb
 - lib/invokable/set.rb
 - lib/invokable/version.rb
 homepage: https://github.com/delonnewman/invokable