invokable 0.5.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b107ca53f8d89104fa38152d27141d24ae62dbec10e8e313b1428b5e711f61e9
-  data.tar.gz: b17e3b4207c4262637a08975772063f8d99583c6ef472220e18598885c272860
+  metadata.gz: 18c3cf809df359e8e89d764f5111d97b33ce63802d5e4ee1c01be83eed583d5c
+  data.tar.gz: b431129c01229cdac6751df4e5d03a756f0852ca9aa6e78cae7e2ff7d7caf36d
 SHA512:
-  metadata.gz: c036b555078552a8902b83ccb7800ce878c23844a3ac6c7586d510622a56ba9ef0e4da985773662d5a605566308bb1c835b28eb988b417cc5a42a1c92aa95464
-  data.tar.gz: 900fab835907e7a8af2f8284629361ed0fbe1db81e6d05d8a2a98152fc223e4a44de352eb1eba538a9e53d406e95d97bcf4ad82f133a96e91c282626999175a7
+  metadata.gz: 56d344edf79caf64a9dec52fba375b2455c889e097dbf5be2fdf074c2ac4ee0eaf3f882e4bf55f638cb47b3de1cc00b57e56cf47910731dea825be8042d1c074
+  data.tar.gz: 465820b6b31e9a99046098fd51ccc6eccc341e9aac0ef2595faca93abde00b6c9de5452fb54b5016b351eb73455c58ecdae8ed84dbb4505c5bb25345fa5e0046

data/.github/workflows/ruby.yml

@@ -1,20 +1,35 @@
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+# This workflow will download a prebuilt Ruby version, install dependencies and run tests with Rake
+# For more information see: https://github.com/marketplace/actions/setup-ruby-jruby-and-truffleruby
+
 name: Ruby
 
-on: [push]
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
 
 jobs:
-  build:
+  test:
 
     runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby-version: ['2.4', '2.5', '2.6', '2.7', '3.0']
 
     steps:
     - uses: actions/checkout@v2
-    - name: Set up Ruby 2.6
-      uses: actions/setup-ruby@v1
+    - name: Set up Ruby
+    # To automatically get bug fixes and new Ruby versions for ruby/setup-ruby,
+    # change this to (see https://github.com/ruby/setup-ruby#versioning):
+    # uses: ruby/setup-ruby@v1
+      uses: ruby/setup-ruby@473e4d8fe5dd94ee328fdfca9f8c9c7afc9dae5e
       with:
-        ruby-version: 2.6.x
-    - name: Build and test with Rake
-      run: |
-        gem install bundler
-        bundle install --jobs 4 --retry 3
-        bundle exec rake
+        ruby-version: ${{ matrix.ruby-version }}
+        bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+    - name: Run tests
+      run: bundle exec rake

data/.gitignore

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

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+ - 2.4
+ - 2.5
+ - 2.6
+ - 2.7
+ - 3.0
+ - jruby

data/CHANGELOG.md

@@ -1,11 +1,67 @@
 # Change Log
 
-## 0.4.2
+## 1.0.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.
+- More robust testing
+- Better error handling
+- Keyword argument support
+
+## 0.7.2
+
+Variable arity invoker methods are handled properly. Variable arity initializers will result in a more meaningful exception being raised.
+
+## 0.7.1
+
+### Invokable::call
+
+When all the arguments of the initializer are passed and the instance method is zero arity the instance method will be called.
+
+```ruby
+class Greeter
+  def initialize(name)
+    @name = name
+  end
+
+  def call
+    "Hello #{name}"
+  end
+end
+
+Greeter.call("Jane") # => "Hello Jane"
+Greeter.call("John") # => #<Greeter ...> (before 0.7.1)
+```
+
+## 0.7.0
+
+- 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.
+
+- 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.
+
+- `[]` and `===` are added to classed that mixin `Invokable` for better `Proc` compatibility.
+
+- `Array`, `Hash` and `Set` patches no longer include the invokable methods, they simply add `to_proc`.
+
+- 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

@@ -1,15 +1,7 @@
 source "https://rubygems.org"
 
-git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
-
-# Specify your gem's dependencies in data-functions.gemspec
 gemspec
 
 group :development do
-  gem 'pry'
   gem 'yard'
 end
-
-group :test do
-  gem 'gen-test'
-end

data/Gemfile.lock

@@ -1,53 +1,38 @@
 PATH
   remote: .
   specs:
-    invokable (0.5.2)
+    invokable (1.0.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    coderay (1.1.2)
-    concurrent-ruby (1.1.5)
-    diff-lcs (1.3)
-    faker (1.9.6)
-      i18n (>= 0.7)
-    gen-test (0.1.1)
-      faker (~> 1.9.6)
-      regexp-examples (~> 1.5.0)
-    i18n (1.8.2)
-      concurrent-ruby (~> 1.0)
-    method_source (0.9.2)
-    pry (0.12.2)
-      coderay (~> 1.1.0)
-      method_source (~> 0.9.0)
+    diff-lcs (1.4.4)
     rake (13.0.1)
-    regexp-examples (1.5.1)
-    rspec (3.9.0)
-      rspec-core (~> 3.9.0)
-      rspec-expectations (~> 3.9.0)
-      rspec-mocks (~> 3.9.0)
-    rspec-core (3.9.1)
-      rspec-support (~> 3.9.1)
-    rspec-expectations (3.9.0)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.0)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.0)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.9.0)
-    rspec-mocks (3.9.1)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.0)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.9.0)
-    rspec-support (3.9.2)
-    yard (0.9.24)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.0)
+    yard (0.9.25)
 
 PLATFORMS
+  java
   ruby
 
 DEPENDENCIES
-  bundler (~> 1.17)
-  gen-test
+  bundler (~> 2.1)
   invokable!
-  pry
   rake (~> 13.0)
   rspec (~> 3.0)
   yard
 
 BUNDLED WITH
-   1.17.3
+   2.2.6

data/README.md

@@ -3,83 +3,131 @@
 
 # Invokable
 
-Objects are functions! Treat any Object, Hashes, Arrays, and Sets as Procs (like Enumerable but for Procs)
+Objects are functions! Treat any Object or Class as a Proc (like Enumerable but for Procs)
 
 ## Synopsis
 
+Objects that enclose state, can be treated as automatically curried functions.
+
 ```ruby
 require 'invokable'
-require 'invokable/hash'
 
-number_names = { 1 => "One", 2 => "Two", 3 => "Three" }
-[1, 2, 3, 4].map(&number_names) # => ["One", "Two", "Three", nil]
+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 ...>
+
+# both the class and it's instances can be used anywhere Procs are.
+
+Model.where(created_at: Date.today).map(&TwitterPoster) # => [#<TwitterPoster ...>, ...]
 ```
 
+Use `memoize`, `<<` and `>>` for composition and other methods on Proc on your command objects
+
 ```ruby
-require 'invokable'
-require 'invokable/array'
+# app/queries/filter_records.rb
+class FilterRecords
+  include Invokable
 
-alpha = ('a'..'z').to_a
-[1, 2, 3, 4].map(&alpha) # => ["b", "c", "d", "e"]
+  def initialize(params)
+    @params = params
+  end
+
+  def call(records)
+    # 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
-require 'invokable'
-require 'invokable/set'
+Invokable.juxtapose(:sum, -> (xs) { xs.reduce(:*) }, :min, :max).([3, 4, 6]) # => [13, 72, 3, 6]
 
-favorite_numbers = Set[3, Math::PI]
-[1, 2, 3, 4].select(&favorite_numbers) # => [3]
+Invokable.knit(:upcase, :downcase).(['FoO', 'BaR']) # => ["FOO", "bar"]
 ```
 
-```ruby
-# service objects
-require 'invokable'
+They are also mixed into any class that includes the module
 
-class GetDataFromSomeService
+```ruby
+class Transformer
   include Invokable
 
-  def call(user)
-    # do the dirt
+  def call(array)
+    array.map(&juxtapose(identity, compose(:to_s, :upcase))).to_h
   end
 end
 
-data_for_user = GetDataFromSomeService.new.memoize # 'memoize' makes a proc that caches results
-User.all.map(&data_for_user)
+Transformer.call([:a, :b, :c, :d]) # => {:a => "A", :b => "B", :c => "C", :d => "D"} 
 ```
+
+Hashes can be treated as functions of their keys
+
 ```ruby
-# command objects that enclose state, can be treated as automatically curried functions.
 require 'invokable'
-require 'invokable/closure'
+require 'invokable/hash'
 
-class TwitterPoster
-  include Invokable::Closure
+number_names = { 1 => "One", 2 => "Two", 3 => "Three" }
+[1, 2, 3, 4].map(&number_names) # => ["One", "Two", "Three", nil]
+```
 
-  enclose :model
+Arrays can be treated as functions of their indexes
 
-  def call(user)
-    # do the dirt
-    ...
-    TwitterStatus.new(user, data)
-  end
-end
+```ruby
+require 'invokable'
+require 'invokable/array'
 
-TwitterPoster.call(Model.find(1)) # => #<TwitterPoster ...>
-TwitterPoster.call(Model.find(1), current_user) # => #<TwitterStatus ...>
+alpha = ('a'..'z').to_a
+[1, 2, 3, 4].map(&alpha) # => ["b", "c", "d", "e"]
+```
 
-# both the class and it's instances can be used any where Procs are.
+Sets can be treated as predicates
 
-Model.where(created_at: Date.today).map(&:TwitterPoster) # => [#<TwitterPoster ...>, ...]
+```ruby
+require 'invokable'
+require 'invokable/set'
+
+favorite_numbers = Set[3, Math::PI]
+[1, 2, 3, 4].select(&favorite_numbers) # => [3]
 ```
 
-Use as much or a little as you need:
+Use as much or a little as you need
 
 ```ruby
 require 'invokable'         # loads Invokable module
-require 'invokable/closure' # loads Invokable::Closure module
+require 'invokable/helpers' # loads Invokable::Helpers 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,38 +152,9 @@ 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`
+## API Documentation
 
-Returns a proc that is a composition of this invokable and the given invokable.
+[https://www.rubydoc.info/gems/invokable](https://www.rubydoc.info/gems/invokable)
 
 ## See Also
 
@@ -143,9 +162,9 @@ Returns a proc that is a composition of this invokable and the given invokable.
   - [Clojure](https://clojure.org)
   - [Arc](http://www.arclanguage.org)
 
-## TODO
+## Support
 
-  - benchmark Invokable#to_proc
+Tested using MRI 2.4, 2.5, 2.6, 2.7, 3.0 and JRuby
 
 ## License
 

data/_config.yml

@@ -0,0 +1 @@
+#theme: jekyll-theme-minimal

data/invokable.gemspec

@@ -36,7 +36,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.17"
+  spec.add_development_dependency "bundler", "~> 2.1"
   spec.add_development_dependency "rake", "~> 13.0"
   spec.add_development_dependency "rspec", "~> 3.0"
 end

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,16 +1,103 @@
+# frozen_string_literal: true
+
 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)
+    INCLUDED_MODULES.each do |mod|
+      base.include(mod)
+      base.extend(mod)
+    end
+    base.extend(ClassMethods)
+  end
+
+  private
+
+  INCLUDED_MODULES = [Core, Helpers].freeze
+  private_constant :INCLUDED_MODULES
+
+  # 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
+    #
+    # @return [Integer]
+    def arity
+      return initializer_arity + invoker_arity if invoker_arity >= 0
+
+      (initializer_arity + invoker_arity.abs) * -1
+    end
+
+    # Handle automatic currying--will accept either the initializer arity or the total arity of the class. If
+    # the initializer arity is used return a class instance. If the total arity is used instantiate the class
+    # and return the results of the `call` method.
+    #
+    # @version 0.6.0
+    #
+    # @see arity
+    def call(*args, **kwargs)
+      initializer = initializer_arity
+      raise ArgumentError, "variable length initializer methods are not supported by Invokable try using `new' or `curry' instead" if initializer < 0
+      raise ArgumentError, "block arguments are not supported by Invokable" if block_given?
+      
+      return new.call if arity.zero?
+  
+      argc    = kwargs.empty? ? args.length : args.length + 1
+      invoker = invoker_arity
+      return new(*args).call           if argc == initializer && invoker.zero? && kwargs.empty?
+      return new(*args, **kwargs).call if argc == initializer && invoker.zero?
+      return new(*args).call           if argc == initializer && invoker == -1 && kwargs.empty?
+      return new(*args).call(**kwargs) if argc == initializer && invoker == -1
+      return new(*args)                if argc == initializer && kwargs.empty?
+      return new(*args, **kwargs)      if argc == initializer
+
+      if argc == arity || invoker_arity < 0 && (args.length - initializer) >= (invoker.abs - 1)
+        init_args = args.slice(0, initializer)
+        call_args = args.slice(initializer, args.length)
+        return new(*init_args).call(*call_args) if kwargs.empty?
+        return new(*init_args).call(*call_args, **kwargs)
+      else
+        raise ArgumentError, "wrong number of arguments (given #{args.length}, expected #{arity})" if initializer == arity
+        raise ArgumentError, "wrong number of arguments (given #{args.length}, expected #{initializer} or #{arity})"
+      end
+    end
+
+    def initializer_arity
+      instance_method(:initialize).arity
+    end
+
+    def invoker_arity
+      instance_method(:call).arity
+    end
   end
 end

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,9 +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 module {Invokable} by default now.
   module Closure
     def self.included(klass)
       klass.include(Invokable)
@@ -31,9 +31,7 @@ module Invokable
       #
       # @return [Integer]
       def initializer_arity
-        return @initializer_arity if @initializer_arity
-
-        @initializer ? @initializer.arity : 0
+        instance_method(:initialize).arity
       end
   
       # Handle automatic currying--will accept either the initializer arity or the total arity of the class. If

data/lib/invokable/command.rb

@@ -3,9 +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} 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.5.2"
+  VERSION = "1.0.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: invokable
 version: !ruby/object:Gem::Version
-  version: 0.5.2
+  version: 1.0.0
 platform: ruby
 authors:
 - Delon Newman
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-07-28 00:00:00.000000000 Z
+date: 2021-01-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.17'
+        version: '2.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.17'
+        version: '2.1'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -63,13 +63,16 @@ files:
 - ".github/workflows/ruby.yml"
 - ".gitignore"
 - ".rspec"
+- ".travis.yml"
 - CHANGELOG.md
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
+- _config.yml
 - invokable.gemspec
+- lib/core_ext.rb
 - lib/invokable.rb
 - lib/invokable/array.rb
 - lib/invokable/closure.rb
@@ -78,8 +81,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 +108,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
+rubygems_version: 3.2.3
 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