invokable 0.5.0 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6dcc085ff857ef0a95578db5f816338c0ade3da6ef4ecb263f86924e4b4e2cfb
-  data.tar.gz: 235f058b7b39b8ff91b8d2580281fad56a388fcea46d19ae3a4bc3657c913d1c
+  metadata.gz: b5a26558a5514a4af779fba9fbc1d015e88fa9c9f2c6a12d88aa274c3307e421
+  data.tar.gz: 633c511d7f4f3509b275b3db38e246303ceed19db80c5dfbbb90df889c7d930f
 SHA512:
-  metadata.gz: bc8294c008fedd2a69337d886515b8fb9c3a2dd6fea8330b15371ffa9b44db0a5ce3c679badede4e2455230db25845ac723b11aa6736f9b62d690b462f7623e9
-  data.tar.gz: f6cab459416371d902933ee1ef3fd24f935bcc0ad7b6c9e0a9bd261bf95d8736c763ec416b94b063acf52fbc4a08df04586ac4b6bde8c02aedcb47b8f8074ef9
+  metadata.gz: 51e7fdfc72e240d55189d69764f9fc8edb35e607eaa1374027d7c1a9478a6428f1bf28aee44971ba8929a75598a4a696a6f02f6370e73b98e0cc03f6cd34d64d
+  data.tar.gz: b553bb218572e6f09af06680fb6c8d3774e3dac8e466f08400d9faf16c74e26cb23f1b00699901caf9db1bf60966d293a01255edfe6ebf9e31dac241c0e107d4

data/.gitignore

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

data/CHANGELOG.md

@@ -1,5 +1,55 @@
 # Change Log
 
+## 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`.

data/Gemfile.lock

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

data/README.md

@@ -3,85 +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/command'
+require 'invokable/hash'
 
-class TwitterPoster
-  include Invokable::Command
+number_names = { 1 => "One", 2 => "Two", 3 => "Three" }
+[1, 2, 3, 4].map(&number_names) # => ["One", "Two", "Three", nil]
+```
 
-  enclose do |model|
-    @model = model
-  end
+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
+
+```ruby
+require 'invokable'
+require 'invokable/set'
 
-Model.where(created_at: Date.today).map(&:TwitterPoster) # => [#<TwitterPoster ...>, ...]
+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/command' # loads Invokable::Command 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?
@@ -106,38 +152,9 @@ Or install it yourself as:
 
     > gem install invokable
 
-## API
+## API Documentation
 
-### `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.
+[https://www.rubydoc.info/gems/invokable](https://www.rubydoc.info/gems/invokable)
 
 ## See Also
 
@@ -145,10 +162,6 @@ Returns a proc that is a composition of this invokable and the given invokable.
   - [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/_config.yml

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

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,87 @@
 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
+
+  # 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
+      initializer_arity + invoker_arity
+    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)
+      return new.call        if arity == 0
+      return new(*args).call if args.length == initializer_arity && invoker_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)
+      else
+        raise ArgumentError, "wrong number of arguments (given #{args.length}, expected #{initializer_arity} or #{arity})"
+      end
+    end
+
+    private
+
+    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

@@ -0,0 +1,114 @@
+module Invokable
+  # Treat classes as curried functions
+  #
+  # @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)
+      klass.extend(Invokable::Core)
+      klass.extend(Invokable::Compose)
+      klass.extend(ClassMethods)
+    end
+
+    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.5.0
+      # @see https://ruby-doc.org/core-2.7.1/Proc.html#method-i-arity Proc#arity
+      # @see initializer_arity
+      #
+      # @return [Integer]
+      def arity
+        initializer_arity + instance_method(:call).arity
+      end
+  
+      # Return the arity of the initializer
+      #
+      # @version 0.5.0
+      # @see arity
+      #
+      # @return [Integer]
+      def initializer_arity
+        instance_method(:initialize).arity
+      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.5.0
+      # @see arity
+      # @see initializer_arity
+      def call(*args)
+        if args.length == initializer_arity
+          new(*args)
+        elsif args.length == arity
+          init_args = args.slice(0, initializer_arity)
+          call_args = args.slice(initializer_arity, args.length)
+          new(*init_args).call(*call_args)
+        else
+          raise ArgumentError, "wrong number of arguments (given #{args.length}, expected #{initializer_arity} or #{arity})"
+        end
+      end
+
+      # Specify any enclosed state with a block or named attributes
+      # 
+      # @example
+      #   class TwitterPater
+      #     include Invokable::Command
+      #
+      #     enclose :api_key
+      #
+      #     def call(user)
+      #       # interact with twitter, return results
+      #     end
+      #   end
+      #
+      #   TwitterPater.new(API_KEY).call(User.find(1))
+      #   TwitterPater.new(API_KEY).api_key == API_KEY # => true
+      #
+      #   class TwitterPater
+      #     include Invokable::Command
+      #
+      #     enclose do |api_key|
+      #       @api_key = api_key
+      #     end
+      #
+      #     def call(user)
+      #       # interact with twitter, return results
+      #     end
+      #   end
+      #
+      #   TwitterPater.new(API_KEY).call(User.find(1))
+      #   TwitterPater.new(API_KEY).api_key # error 'method' missing
+      def enclose(*names, &block)
+        return define_initializer_with_block(block) unless block.nil?
+
+        define_initializer_with_names(names)
+      end
+  
+      private
+
+      def define_initializer_with_block(block)
+        @initializer = block
+        define_method :initialize, &block
+      end
+
+      def define_initializer_with_names(names)
+        @initializer_arity = names.length
+
+        names.each do |name|
+          attr_reader name
+        end
+
+        define_method :initialize do |*args|
+          names.each_with_index do |name, i|
+            instance_variable_set(:"@#{name}", args[i])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/invokable/command.rb

@@ -1,65 +1,17 @@
+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)
       klass.extend(Invokable::Core)
       klass.extend(Invokable::Compose)
-      klass.extend(ClassMethods)
-    end
-
-    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.5.0
-      # @see https://ruby-doc.org/core-2.7.1/Proc.html#method-i-arity Proc#arity
-      # @see initializer_arity
-      #
-      # @return [Integer]
-      def arity
-        initializer_arity + instance_method(:call).arity
-      end
-  
-      # Return the arity of the initializer
-      #
-      # @version 0.5.0
-      # @see arity
-      #
-      # @return [Integer]
-      def initializer_arity
-        @initializer ? @initializer.arity : 0
-      end
-  
-      # To specify any enclosed state
-      def enclose(&block)
-        raise 'A block is required' if block.nil?
-  
-        @initializer = block
-        define_method :initialize, &block
-      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.5.0
-      # @see arity
-      # @see initializer_arity
-      def call(*args)
-        if args.length == initializer_arity
-          new(*args)
-        elsif args.length == arity
-          init_args = args.slice(0, initializer_arity)
-          call_args = args.slice(initializer_arity, args.length)
-          new(*init_args).call(*call_args)
-        else
-          raise "Wrong number of arguments expected #{initializer_arity} or #{arity}, got: #{args.length}"
-        end
-      end
+      klass.extend(Invokable::Closure::ClassMethods)
     end
   end
 end

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.0"
+  VERSION = "0.7.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: invokable
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.7.1
 platform: ruby
 authors:
 - Delon Newman
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-07-21 00:00:00.000000000 Z
+date: 2020-09-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -69,16 +69,18 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- _config.yml
 - invokable.gemspec
+- lib/core_ext.rb
 - lib/invokable.rb
 - lib/invokable/array.rb
+- lib/invokable/closure.rb
 - lib/invokable/command.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/helpers.rb
 - lib/invokable/set.rb
 - lib/invokable/version.rb
 homepage: https://github.com/delonnewman/invokable

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