invokable 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b1c89f44b80135945cce3300f6f9b8e5b1210282d8c3d10256c2593ccf281948
-  data.tar.gz: 2a0e9ce82c10b9f57b1767087d56b5d53a67bdfeb139e5a642fb071a9bc6a8e6
+  metadata.gz: 8285e8008ed711e2898713904adabd60c274f60a5d21b0995443c62bc9bd5ad9
+  data.tar.gz: 935b77cfdc76c309cd7bb6866fb85cfa823f8fa7cefc399fd7b6e6e1018b7f83
 SHA512:
-  metadata.gz: 20d8a431d84d973709f122211c8e606d4ac43e162c54a7bdf8e7507873c0235dede63a8e73a69d296152b6020ebd93a3001be8c73916dee7a7cfbcc6c600b0df
-  data.tar.gz: c1df682d8c7eed2525d7a2eaadce3e5dedb8114b18d64df3f7e323995b7c30c31827d2c6f2da94738094c06614a74bf4309dc20a1d3a2e9b66152c6e265b7035
+  metadata.gz: 8d501dca816dbdf3b49381f55b771564975886a1f3cd2d96946142301abaf833e5733ca77741e45ab3ec9975878b61022640d8c90226426a5e25c79d28734709
+  data.tar.gz: c4719b7d18dd692b933c2648504cd511136481c2256b0c670ecd09e1adbf7d7a9e31b17b2bb45b8ef7cf725a5063dd970c6344efef7c84c0fd3c4d269f30bfa5

data/.gitignore

@@ -10,3 +10,4 @@
 # rspec failure tracking
 .rspec_status
 tags
+.DS_Store

data/CHANGELOG.md

@@ -1,19 +1,36 @@
 # Change Log
 
-## 0.4.2
+## 0.7.0
 
-- `invokable/array` is no longer loaded with `invokable/data`.
-   This created a bit of havok in a few places. Including breaking
-   puma bootup in Rails 5.2.4.1.
+- Added helper methods `juxtapose`, `knit`, `compose`, `identity`, `always`, `guarded`, `partial`, and `coerce`
+  that can be used as module functions on `Invokable` or in classes that mixin the `Invokable` module.
 
-## 0.5.0
+- For classes whose initialize method takes no arguments, when the class method `call` is called it will
+  initialize the class and call it's `call` method.
 
-- Added `Invokable::Command` and `Invokable::Core#arity`
+- `[]` and `===` are added to classed that mixin `Invokable` for better `Proc` compatibility.
 
-## 0.5.2
+- `Array`, `Hash` and `Set` patches no longer include the invokable methods, they simply add `to_proc`.
 
-- `Invokable::Command` deprecated in favor of `Invokable::Closure`.
+- When `invokable/data` is required the array patch is also loaded.
+
+- All the methods that take an invokable will "coerce" the invokable by simply returning it if it implements `call`
+  or coercing it into a proc if it implements `to_proc`.
 
 ## 0.6.0
 
 - `Invokable::Closure` deprecated comparable behavior has been added to `Invokable` itself.
+
+## 0.5.2
+
+- `Invokable::Command` deprecated in favor of `Invokable::Closure`.
+
+## 0.5.0
+
+- Added `Invokable::Command` and `Invokable::Core#arity`
+
+## 0.4.2
+
+- `invokable/array` is no longer loaded with `invokable/data`.
+   This created a bit of havok in a few places. Including breaking
+   puma bootup in Rails 5.2.4.1.

data/Gemfile.lock

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

data/README.md

@@ -3,10 +3,12 @@
 
 # Invokable
 
-Objects are functions! Treat any Object, Hashes, Arrays, and Sets as Procs (like Enumerable but for Procs)
+Objects are functions! Treat any Object, Class, Hashes, Arrays, and Sets as Procs (like Enumerable but for Procs)
 
 ## Synopsis
 
+Hashes can be treated as functions of their keys
+
 ```ruby
 require 'invokable'
 require 'invokable/hash'
@@ -15,6 +17,8 @@ number_names = { 1 => "One", 2 => "Two", 3 => "Three" }
 [1, 2, 3, 4].map(&number_names) # => ["One", "Two", "Three", nil]
 ```
 
+Arrays can be treated as functions of their indexes
+
 ```ruby
 require 'invokable'
 require 'invokable/array'
@@ -23,6 +27,8 @@ alpha = ('a'..'z').to_a
 [1, 2, 3, 4].map(&alpha) # => ["b", "c", "d", "e"]
 ```
 
+Sets can be treated as predicates
+
 ```ruby
 require 'invokable'
 require 'invokable/set'
@@ -31,23 +37,9 @@ favorite_numbers = Set[3, Math::PI]
 [1, 2, 3, 4].select(&favorite_numbers) # => [3]
 ```
 
-```ruby
-# service objects
-require 'invokable'
-
-class GetDataFromSomeService
-  include Invokable
-
-  def call(user)
-    # do the dirt
-  end
-end
+Objects that enclose state, can be treated as automatically curried functions.
 
-data_for_user = GetDataFromSomeService.new.memoize # 'memoize' makes a proc that caches results
-User.all.map(&data_for_user)
-```
 ```ruby
-# command objects that enclose state, can be treated as automatically curried functions.
 require 'invokable'
 
 class TwitterPoster
@@ -72,14 +64,69 @@ TwitterPoster.call(Model.find(1), current_user) # => #<TwitterStatus ...>
 Model.where(created_at: Date.today).map(&TwitterPoster) # => [#<TwitterPoster ...>, ...]
 ```
 
-Use as much or a little as you need:
+Use `memoize`, `<<` and `>>` for composition and other methods on Proc on your command objects
+
+```ruby
+# app/queries/filter_records.rb
+class FilterRecords
+  include Invokable
+
+  def initialize(params)
+    @params = params
+  end
+
+  def call(params)
+    # do filtering return records
+  end
+end
+
+# app/queries/sort_records.rb
+class SortRecords
+  include Invokable
+
+  def initialize(params)
+    @params = params
+  end
+
+  def call(records)
+    # do sorting return records
+  end
+end
+
+sort_and_filter = SortRecords.call(params) << FilterRecords.call(params)
+sort_and_filter.call(records) # => sorted and filtered records
+```
+
+Helper methods that can be used with any object that responds to `call` or `to_proc`
+
+```ruby
+Invokable.juxtapose(:sum, -> (xs) { xs.reduce(:*) }, :min, :max).([3, 4, 6]) # => [13, 72, 3, 6]
+
+Invokable.knit(:upcase, :downcase).(['FoO', 'BaR']) # => ["FOO", "bar"]
+```
+
+They are also mixed into any class that includes the module
+
+```ruby
+class Transformer
+  include Invokable
+
+  def call(array)
+    array.map(&juxtapose(identity, compose(:to_s, :upcase))).to_h
+  end
+end
+
+Transformer.call([:a, :b, :c, :d]) # => {:a => "A", :b => "B", :c => "C", :d => "D"} 
+```
+
+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 hash and set patches
+require 'invokable/data'    # loads hash, set and array patches
 ```
 
 ## Why?
@@ -104,49 +151,12 @@ Or install it yourself as:
 
     > gem install invokable
 
-## API
-
-### `to_proc => Proc`
-
-```ruby
-hash = { a: 1, b, 2 }
-hash.class          # => Hash
-hash.to_proc.class  # => Proc
-[:a, :b].map(&hash) # => [1, 2]
-```
-
-Convert an object into a proc. When the `Invokable` module is included in a class it will do this by
-returning a proc that passes it's arguments to the object's `call` method. When `invokable/data` is
-loaded `Hash#call` is mapped to `Hash#dig`, `Array#call` is mapped to `Array#at`, and `Set#call`
-is mapped to `Set#include?`.
-
-### `curry(arity = nil) => Proc`
-
-Returns a curried proc. If the `arity` is given, it determines the number of arguments.
-(see [Proc#curry](https://ruby-doc.org/core-2.7.0/Proc.html#method-i-curry)).
-
-### `memoize => Proc`
-
-Returns a memoized proc, that is, a proc that caches it's return values by it's arguments.
-
-### `<<(invokable) => Proc`
-
-Returns a proc that is a composition of this invokable and the given invokable.
-
-### `>>(invokable) => Proc`
-
-Returns a proc that is a composition of this invokable and the given invokable.
-
 ## See Also
 
   - [Closures and Objects are Equivalent](http://wiki.c2.com/?ClosuresAndObjectsAreEquivalent)
   - [Clojure](https://clojure.org)
   - [Arc](http://www.arclanguage.org)
 
-## TODO
-
-  - benchmark Invokable#to_proc
-
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/core_ext.rb

@@ -0,0 +1,15 @@
+if RUBY_VERSION.split('.').take(2).join('.').to_f < 2.6
+  # Add {<<} and {>>} for right and left function composition.
+  #
+  # @note These methods were added to Ruby in version 2.6 so this patch will only be applied when running older versions.
+  class Proc
+    include Invokable::Compose
+  end
+
+  # Add {<<} and {>>} for right and left function composition.
+  #
+  # @note These methods were added to Ruby in version 2.6 so this patch will only be applied when running older versions.
+  class Method
+    include Invokable::Compose
+  end
+end

data/lib/invokable.rb

@@ -1,28 +1,52 @@
 require 'invokable/version'
 require 'invokable/core'
-require 'invokable/compose'
-
-# TODO: make use of Gem::Version
-if RUBY_VERSION.split('.').take(2).join('.').to_f < 2.6
-  require 'invokable/proc'
-  require 'invokable/method'
-end
+require 'invokable/helpers'
+require 'core_ext'
 
+# A module that attempts to generalize the notion of a first class function or Procs as they are often called
+# in Ruby. It enables any class and it's objects to be treated as first-class functions. It also provides helpers
+# includes helpers that can be used for performing higher-order operations on and object that can be treated
+# as a function.
+#
+# @example
+#   class TwitterPoster
+#     include Invokable
+#   
+#     def initialize(model)
+#       @model = model
+#     end
+#   
+#     def call(user)
+#       # do the dirt
+#       ...
+#       TwitterStatus.new(user, data)
+#     end
+#   end
+#   
+#   TwitterPoster.call(Model.find(1)) # => #<TwitterPoster ...>
+#   TwitterPoster.call(Model.find(1), current_user) # => #<TwitterStatus ...>
 module Invokable
+  extend Invokable::Helpers
+
   def self.included(base)
-    base.include(Invokable::Core)
-    base.include(Invokable::Compose)
-    base.extend(Invokable::Core)
-    base.extend(Invokable::Compose)
+    INCLUDED_MODULES.each do |mod|
+      base.include(mod)
+      base.extend(mod)
+    end
     base.extend(ClassMethods)
   end
 
+  private
+
+  INCLUDED_MODULES = [Core, Helpers].freeze
+
+  # The methods that are mixed into any class at the class level that includes {Invokable}.
+  #
+  # @note The module should not be used directly.
   module ClassMethods
     # Return the "total" arity of the class (i.e. the arity of the initializer and the arity of the call method)
     #
     # @version 0.6.0
-    # @see https://ruby-doc.org/core-2.7.1/Proc.html#method-i-arity Proc#arity
-    # @see initializer_arity
     #
     # @return [Integer]
     def arity
@@ -34,12 +58,13 @@ module Invokable
     # and return the results of the `call` method.
     #
     # @version 0.6.0
+    #
     # @see arity
-    # @see initializer_arity
     def call(*args)
-      if args.length == initializer_arity
-        new(*args)
-      elsif args.length == arity
+      return new.call   if arity == 0
+      return new(*args) if args.length == initializer_arity
+
+      if args.length == arity
         init_args = args.slice(0, initializer_arity)
         call_args = args.slice(initializer_arity, args.length)
         new(*init_args).call(*call_args)

data/lib/invokable/array.rb

@@ -1,10 +1,13 @@
-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#[]
+# Extend core Array by adding {to_proc} which will enable arrays to be treated as functions
+# of their indexes.
 class Array
-  include Invokable::Core
-  alias call []
+  # Return a proc that takes the index of the array and returns the value at that index or nil
+  # if there is no value at the given index.
+  #
+  # @return [Proc]
+  def to_proc
+    lambda do |index|
+      at(index)
+    end
+  end
 end

data/lib/invokable/closure.rb

@@ -1,10 +1,9 @@
 module Invokable
   # Treat classes as curried functions
   #
-  # @see https://ruby-doc.org/core-2.7.0/Proc.html#method-i-curry Proc#curry
-  #
   # @version 0.5.2
-  # @deprecated These features are included in the Invokable by default now.
+  #
+  # @deprecated These features are included in the module {Invokable} by default now.
   module Closure
     def self.included(klass)
       klass.include(Invokable)

data/lib/invokable/command.rb

@@ -3,10 +3,9 @@ require_relative 'closure'
 module Invokable
   # Treat "Command Objects" as curried functions
   #
-  # @see https://ruby-doc.org/core-2.7.0/Proc.html#method-i-curry Proc#curry
-  #
   # @version 0.5.0
-  # @deprecated These features are included in the Invokable by default now.
+  #
+  # @deprecated These features are included in the {Invokable} module by default now.
   module Command
     def self.included(klass)
       klass.include(Invokable)

data/lib/invokable/compose.rb

@@ -1,24 +1,30 @@
 module Invokable
+  # The {<<} and {>>} methods for right and left function composition.
+  # 
+  # This module is included in the {Invokable} module and the Proc and Method classes
+  # when used with versions of Ruby earlier than 2.6 (when they were added).
+  #
+  # @note This module should not be used directly.
   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
+    # 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))
+      lambda do |*args|
+        call(Invokable.coerce(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
+    # 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))
+      lambda do |*args|
+        Invokable.coerce(invokable).call(call(*args))
       end
     end
   end

data/lib/invokable/core.rb

@@ -1,26 +1,27 @@
+require_relative 'compose'
+
 module Invokable
+  # The core methods that are mixed into classes at a class and instance level when they
+  # include {Invokable}.
+  #
+  # @note This module should not be used directly.
   module Core
-    # If object responds to `call` convert into a Proc forwards it's arguments along to `call`.
+    include Compose
+
+    # Return a Proc that 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"
+      lambda do |*args|
+        call(*args)
       end
     end
   
-    # Return a curried proc. If the optional `arity` argument is given, it determines the number of arguments.
+    # 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)
@@ -31,19 +32,34 @@ module Invokable
     #
     # @return [Proc]
     def memoize
-      Proc.new do |*args|
+      lambda do |*args|
         @memo ||= {}
         @memo[args.hash] ||= call(*args)
       end
     end
 
-    # Return the arity (i.e. the number of arguments) of the `call` method.
+    # Return the arity (i.e. the number of arguments) of the "call" method.
     #
     # @version 0.5.0
-    # @see https://ruby-doc.org/core-2.7.1/Proc.html#method-i-arity Proc#arity
+    #
     # @return [Integer]
     def arity
       method(:call).arity
     end
+
+    # For Proc compatibility, forwards it's arguments to "call".
+    #
+    # @version 0.7.0
+    def [](*args)
+      call(*args)
+    end
+
+    # Call invokable with one argument, allows invocables to be used in case statements
+    # and Enumerable#grep.
+    #
+    # @version 0.7.0
+    def ===(obj)
+      call(obj)
+    end
   end
 end

data/lib/invokable/data.rb

@@ -1,2 +1,3 @@
 require_relative 'hash'
 require_relative 'set'
+require_relative 'array'

data/lib/invokable/hash.rb

@@ -1,12 +1,16 @@
-require_relative 'core'
-
-# Extend core Hash object by aliasing it's `dig` method as `call`,
-# and including the `Invokable` module.
+# Extend core Hash object by adding {to_proc} so hashes can be treated as functions of their keys.
 #
-# @see https://ruby-doc.org/core-2.7.0/Hash.html#method-i-dig Hash#dig
+# @note {to_proc} was added to Hash in Ruby 2.7 so this patch is only applied for older versions of Ruby.
 class Hash
   if RUBY_VERSION.split('.').take(2).join('.').to_f < 2.7
-    include Invokable::Core
-    alias call dig
+    # Return a proc that takes a key and returns the value associated with it or nil if the key
+    # is not present in the hash.
+    #
+    # @return [Proc]
+    def to_proc
+      lambda do |key|
+        fetch(key) { nil }
+      end
+    end
   end
 end

data/lib/invokable/helpers.rb

@@ -0,0 +1,141 @@
+module Invokable
+  # A collection of helper methods for working with invokables where they accept and invokable
+  # as an argument they will "coerce" the value (see {coerce}). This enables any method that
+  # implements `call` or `to_proc` to be treated as an invokable.
+  #
+  # @version 0.7.0
+  module Helpers
+    # Return a proc that returns the value that is passed to it.
+    #
+    # @version 0.7.0
+    #
+    # @return [Proc]
+    def identity
+      lambda do |x|
+        x
+      end
+    end
+  
+    # Return a proc that will always return the value given it.
+    #
+    # @version 0.7.0
+    #
+    # @return [Proc]
+    def always(x)
+      lambda do
+        x
+      end
+    end
+  
+    # If the invokable passed responds to :call it will be returned. If it responds to to_proc to_proc
+    # is called and the resulting proc is returned. Otherwise a TypeError will be raised.
+    #
+    # @version 0.7.0
+    def coerce(invokable)
+      return invokable         if invokable.respond_to?(:call)
+      return invokable.to_proc if invokable.respond_to?(:to_proc)
+  
+      raise TypeError, "#{invokable.inspect} is not a valid invokable"
+    end
+  
+    # Return a proc that passes it's arguments to the given invokables and returns an array of results.
+    # The invokables passed will be coerced before they are called (see {coerce}).
+    #
+    # @version 0.7.0
+    #
+    # @example
+    #   juxtapose(:first, :count).call('A'..'Z') # => ["A", 26]
+    #
+    # @return [Proc]
+    def juxtapose(*invokables)
+      lambda do |*args|
+        invokables.map do |invokable|
+          coerce(invokable).call(*args)
+        end
+      end
+    end
+    alias juxt juxtapose
+  
+    # A relative of {juxtapose}--return a proc that takes a collection and calls the invokables
+    # on their corresponding values (in sequence) in the collection. The invokables passed
+    # will be coerced before they are called (see {coerce}).
+    #
+    # @version 0.7.0
+    #
+    # @example
+    #   knit(:upcase, :downcase).call(['FoO', 'BaR']) # => ["FOO", "bar"]
+    # 
+    # @return [Proc]
+    def knit(*invokables)
+      lambda do |enumerable|
+        results = []
+        enumerable.each_with_index do |x, i|
+          return results if invokables[i].nil?
+  
+          results << coerce(invokables[i]).call(x)
+        end
+        results
+      end
+    end
+    
+    # Return a proc that is a composition of the given invokables from right-to-left. The invokables
+    # passed will be coerced before they are called (see {coerce}).
+    #
+    # @version 0.7.0
+    #
+    # @example
+    #   compose(:to_s, :upcase).call(:this_is_a_test) # => "THIS_IS_A_TEST"
+    #
+    # @return [Proc]
+    def compose(*invokables)
+      return identity              if invokables.empty?
+      return coerce(invokables[0]) if invokables.count == 1
+  
+      if invokables.count == 2
+        f, g = invokables
+        return lambda do |*args|
+          coerce(f).call(coerce(g).call(*args))
+        end
+      end
+  
+      invokables.reduce do |a, b|
+        compose(a, b)
+      end
+    end
+  
+    # Return a proc that guards it's arguments from nil by replacing nil values with the alternative
+    # value that corresponds to it's place in the argument list. The invokable passed will be coerced
+    # before they are called (see {coerce}).
+    #
+    # @version 0.7.0
+    #
+    # @example
+    #   count = guarded(:count, [])
+    #   count.call(nil) # => 0
+    #   count.call([1]) # => 1
+    #
+    # @return [Proc]
+    def guarded(invokable, *alternatives)
+      lambda do |*args|
+        new_args = args.each_with_index.map do |x, i|
+          x.nil? ? alternatives[i] : x
+        end
+        coerce(invokable).call(*new_args)
+      end
+    end
+    alias fnil guarded
+    alias nil_safe guarded
+  
+    # Given an invokable and and a fewer number of arguments that the invokable takes return
+    # a proc that will accept the rest of the arguments (i.e. a partialy applied function).
+    # 
+    # @version 0.7.0
+    #
+    # @return [Proc]
+    def partial(invokable, *args)
+      lambda do |*other_args|
+        coerce(invokable).call(*(args + other_args))
+      end
+    end
+  end
+end

data/lib/invokable/set.rb

@@ -1,11 +1,15 @@
 require 'set'
-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?
+# Extend stdlib Set object by adding {to_proc} which will allow a set to be treated as a function of
+# the membership of it's elements.
 class Set
-  include Invokable::Core
-  alias call include?
+  # Return a proc that takes an value and return true if the value is an element of the set, but returns
+  # false otherwise.
+  #
+  # @return [Proc]
+  def to_proc
+    lambda do |element|
+      include?(element)
+    end
+  end
 end

data/lib/invokable/version.rb

@@ -1,3 +1,3 @@
 module Invokable
-  VERSION = "0.6.0"
+  VERSION = "0.7.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: invokable
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Delon Newman
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-08-06 00:00:00.000000000 Z
+date: 2020-08-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -70,6 +70,7 @@ files:
 - README.md
 - Rakefile
 - invokable.gemspec
+- lib/core_ext.rb
 - lib/invokable.rb
 - lib/invokable/array.rb
 - lib/invokable/closure.rb
@@ -78,8 +79,7 @@ files:
 - lib/invokable/core.rb
 - lib/invokable/data.rb
 - lib/invokable/hash.rb
-- lib/invokable/method.rb
-- lib/invokable/proc.rb
+- lib/invokable/helpers.rb
 - lib/invokable/set.rb
 - lib/invokable/version.rb
 homepage: https://github.com/delonnewman/invokable
@@ -106,7 +106,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
+rubygems_version: 3.0.8
 signing_key:
 specification_version: 4
 summary: Objects are functions! Treat any Object, Hashes, Arrays and Sets as Procs

data/lib/invokable/method.rb

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

data/lib/invokable/proc.rb

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