invokable 0.4.2 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0f703edf97638d502bd35c3717fb629355e17f7f1d2468376698baec50c8b495
-  data.tar.gz: a04e0e82205103781a0fff545a3a8dceb37a9eebf0103c01996331b4a060d877
+  metadata.gz: 8285e8008ed711e2898713904adabd60c274f60a5d21b0995443c62bc9bd5ad9
+  data.tar.gz: 935b77cfdc76c309cd7bb6866fb85cfa823f8fa7cefc399fd7b6e6e1018b7f83
 SHA512:
-  metadata.gz: e79339f1c7b207ac86f2c083009e6a51972099e57fa03e3c45f45bb1b0dddf2f9c1f3fd33adab6230dac951466f3fba9b9671130c40af283ff9d2439f98fe919
-  data.tar.gz: 87263922f9790fc9dda1acc43df77cd0c3077f57998d2364ad91bdd27b2d0495455369a3a18c8026eac2623d4d2f32e1e05b61a89f9e2d55e15197329848a7cd
+  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,5 +1,34 @@
 # Change Log
 
+## 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.4.2)
+    invokable (0.7.0)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -3,55 +3,130 @@
 
 # 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/hash'
+require 'invokable'
+require 'invokable/hash'
 
-  number_names = { 1 => "One", 2 => "Two", 3 => "Three" }
-  [1, 2, 3, 4].map(&number_names) # => ["One", "Two", "Three", nil]
+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/array'
+require 'invokable'
+require 'invokable/array'
 
-  alpha = ('a'..'z').to_a
-  [1, 2, 3, 4].map(&alpha) # => ["b", "c", "d", "e"]
+alpha = ('a'..'z').to_a
+[1, 2, 3, 4].map(&alpha) # => ["b", "c", "d", "e"]
 ```
 
+Sets can be treated as predicates
+
 ```ruby
-  require 'invokable/set'
+require 'invokable'
+require 'invokable/set'
+
+favorite_numbers = Set[3, Math::PI]
+[1, 2, 3, 4].select(&favorite_numbers) # => [3]
+```
+
+Objects that enclose state, can be treated as automatically curried functions.
+
+```ruby
+require 'invokable'
+
+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
+# 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
 
-  favorite_numbers = Set[3, Math::PI]
-  [1, 2, 3, 4].select(&favorite_numbers) # => [3]
+  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'
+Invokable.juxtapose(:sum, -> (xs) { xs.reduce(:*) }, :min, :max).([3, 4, 6]) # => [13, 72, 3, 6]
+
+Invokable.knit(:upcase, :downcase).(['FoO', 'BaR']) # => ["FOO", "bar"]
+```
 
-  # service objects
-  class GetDataFromSomeService
-    include Invokable
+They are also mixed into any class that includes the module
 
-    def call(user)
-      # do the dirt
-    end
+```ruby
+class Transformer
+  include Invokable
+
+  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"} 
 ```
 
-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/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?
@@ -76,48 +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,15 +1,82 @@
 require 'invokable/version'
 require 'invokable/core'
-require 'invokable/compose'
-
-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 + instance_method(:call).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) 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
   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

@@ -0,0 +1,17 @@
+require_relative 'closure'
+
+module Invokable
+  # Treat "Command Objects" as curried functions
+  #
+  # @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(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,10 +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.
+    #
+    # @version 0.5.0
+    #
+    # @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,3 +1,3 @@
-require_relative 'core'
 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.4.2"
+  VERSION = "0.7.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: invokable
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.7.0
 platform: ruby
 authors:
 - Delon Newman
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-03-19 00:00:00.000000000 Z
+date: 2020-08-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -70,14 +70,16 @@ files:
 - README.md
 - Rakefile
 - 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
@@ -89,7 +91,7 @@ metadata:
   source_code_uri: https://github.com/delonnewman/invokable
   changelog_uri: https://github.com/delonnewman/invokable#changelog
   documentation_uri: https://www.rubydoc.info/gems/invokable
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -104,8 +106,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
-signing_key: 
+rubygems_version: 3.0.8
+signing_key:
 specification_version: 4
 summary: Objects are functions! Treat any Object, Hashes, Arrays and Sets as Procs
   (like Enumerable but for Proc-like objects)

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