resonad 1.3.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2751182e01f6cf2c97cdc99d46cb716ec1e517d52680bc75c92fd0f5c1bd693f
-  data.tar.gz: 2d1a5a21e81f7da804fa099d16a8b3a2032472e6f89112e4284942d050087293
+  metadata.gz: ccc1511640a1e8dd3c741c16aa80e689c93e159bb47cfedb09072c0de78d9f95
+  data.tar.gz: 8f460dba7216f3da4b03767760a432f7f92d08f166b54fda91e6a076a451db59
 SHA512:
-  metadata.gz: 6571a2f2e4e2ae98dee8c40efbf0bccf0aed09b6bc18cce47a5fb3fc83cc77c32141b31807d9b64b2842c62dfc737025ac24234dc22a1285f0e9910dae97cced
-  data.tar.gz: a000acabecf552daebeff7f10b1e57ab44f7fba224e8e85deb25acb7904b0c97981453931f008b68547b2fdade0e3ebec8d8b868af6757f4271a4a434f075cdb
+  metadata.gz: 188e6c3752ca5b3f5c0e8c1a631a2378f33d239b448163e4425b486906ad1ddb36b5beb4efee703994909fe6f41b7107c2a9a3bc20e87aa1ca2a6c84302b8f63
+  data.tar.gz: bd9ee0e6297db8633ca0826821c1a5a357a53b075625b62b7da822076ae901916b994709e2c784b6e281f919dabd7b642bb9ff2a632ab1f8e05db45e6c0ee88b

data/README.md

@@ -202,6 +202,30 @@ do_step_1
 
 There are lots of aliases for these methods. See the "Aliases" section above.
 
+## Callable Object Arguments
+
+Anywhere that you can use a block argument, you have the ability to
+provide a callable object instead.
+
+For example, this block argument:
+
+```ruby
+Resonad.Success(42).map { |x| x * 2 }
+#=> 84
+```
+
+Could also be given as an object that implements `#call`:
+
+```ruby
+class Doubler
+  def call(x)
+    x * 2
+  end
+end
+
+Resonad.Success(42).map(Doubler.new)
+#=> 84
+```
 
 ## Pattern Matching Support
 

data/lib/resonad.rb

@@ -22,47 +22,49 @@ class Resonad
       true
     end
 
-    def on_success
-      yield value
-      self
+    def deconstruct
+      [:success, value]
     end
 
-    def on_failure
-      self
+    def deconstruct_keys(_)
+      { value: value }
     end
 
     def error
       raise NonExistentError, "Success resonads do not have errors"
     end
 
-    def map
-      new_value = yield(value)
-      if new_value.__id__ == value.__id__
+    private
+
+      def __on_success(callable)
+        callable.(value)
         self
-      else
-        self.class.new(new_value)
       end
-    end
 
-    def map_error
-      self
-    end
+      def __on_failure(_)
+        self
+      end
 
-    def flat_map
-      yield value
-    end
+      def __map(callable)
+        new_value = callable.(value)
+        if new_value.__id__ == value.__id__
+          self
+        else
+          self.class.new(new_value)
+        end
+      end
 
-    def flat_map_error
-      self
-    end
+      def __map_error(_)
+        self
+      end
 
-    def deconstruct
-      [:success, value]
-    end
+      def __flat_map(callable)
+        callable.(value)
+      end
 
-    def deconstruct_keys(_)
-      { value: value }
-    end
+      def __flat_map_error(_)
+        self
+      end
   end
 
   class Failure < Resonad
@@ -85,47 +87,49 @@ class Resonad
       false
     end
 
-    def on_success
-      self
+    def value
+      raise NonExistentValue, "Failure resonads do not have values"
     end
 
-    def on_failure
-      yield error
-      self
+    def deconstruct
+      [:failure, error]
     end
 
-    def value
-      raise NonExistentValue, "Failure resonads do no have values"
+    def deconstruct_keys(_)
+      { error: error }
     end
 
-    def map
-      self
-    end
+    private
 
-    def map_error
-      new_error = yield(error)
-      if new_error.__id__ == error.__id__
+      def __map(_)
         self
-      else
-        self.class.new(new_error)
       end
-    end
 
-    def flat_map
-      self
-    end
+      def __on_success(_)
+        self
+      end
 
-    def flat_map_error
-      yield error
-    end
+      def __on_failure(callable)
+        callable.(error)
+        self
+      end
 
-    def deconstruct
-      [:failure, error]
-    end
+      def __map_error(callable)
+        new_error = callable.(error)
+        if new_error.__id__ == error.__id__
+          self
+        else
+          self.class.new(new_error)
+        end
+      end
 
-    def deconstruct_keys(_)
-      { error: error }
-    end
+      def __flat_map(_)
+        self
+      end
+
+      def __flat_map_error(callable)
+        callable.(error)
+      end
   end
 
   module PublicMixin
@@ -175,46 +179,76 @@ class Resonad
   def failed?; failure?; end
   def bad?; failure?; end
 
-  def map(&block)
-    raise NotImplementedError, "should be implemented in subclass"
-  end
-  def map_value(&block); map(&block); end
+  def map(callable=nil, &block);       __map(callable_from_args(callable, block)); end
+  def map_value(callable=nil, &block); __map(callable_from_args(callable, block)); end
+
+  def map_error(callable=nil, &block); __map_error(callable_from_args(callable, block)); end
+
+  def flat_map(callable=nil, &block); __flat_map(callable_from_args(callable, block)); end
+  def and_then(callable=nil, &block); __flat_map(callable_from_args(callable, block)); end
+
+  def flat_map_error(callable=nil, &block); __flat_map_error(callable_from_args(callable, block)); end
+  def or_else(callable=nil, &block);        __flat_map_error(callable_from_args(callable, block)); end
+  def otherwise(callable=nil, &block);      __flat_map_error(callable_from_args(callable, block)); end
+
+  def on_success(callable=nil, &block);      __on_success(callable_from_args(callable, block)); end
+  def if_success(callable=nil, &block);      __on_success(callable_from_args(callable, block)); end
+  def when_success(callable=nil, &block);    __on_success(callable_from_args(callable, block)); end
+  def on_ok(callable=nil, &block);           __on_success(callable_from_args(callable, block)); end
+  def if_ok(callable=nil, &block);           __on_success(callable_from_args(callable, block)); end
+  def when_ok(callable=nil, &block);         __on_success(callable_from_args(callable, block)); end
+  def on_successful(callable=nil, &block);   __on_success(callable_from_args(callable, block)); end
+  def if_successful(callable=nil, &block);   __on_success(callable_from_args(callable, block)); end
+  def when_successful(callable=nil, &block); __on_success(callable_from_args(callable, block)); end
+
+  def on_failure(callable=nil, &block);   __on_failure(callable_from_args(callable, block)); end
+  def if_failure(callable=nil, &block);   __on_failure(callable_from_args(callable, block)); end
+  def when_failure(callable=nil, &block); __on_failure(callable_from_args(callable, block)); end
+  def on_bad(callable=nil, &block);       __on_failure(callable_from_args(callable, block)); end
+  def if_bad(callable=nil, &block);       __on_failure(callable_from_args(callable, block)); end
+  def when_bad(callable=nil, &block);     __on_failure(callable_from_args(callable, block)); end
+  def on_failed(callable=nil, &block);    __on_failure(callable_from_args(callable, block)); end
+  def if_failed(callable=nil, &block);    __on_failure(callable_from_args(callable, block)); end
+  def when_failed(callable=nil, &block);  __on_failure(callable_from_args(callable, block)); end
 
-  def flat_map
-    raise NotImplementedError, "should be implemented in subclass"
-  end
-  def and_then(&block); flat_map(&block); end
+  NIL_SUCCESS = Success.new(nil)
+  NIL_FAILURE = Failure.new(nil)
 
-  def flat_map_error
-    raise NotImplementedError, "should be implemented in subclass"
-  end
-  def or_else(&block); flat_map_error(&block); end
-  def otherwise(&block); flat_map_error(&block); end
+  private
 
-  def on_success(&block)
-    raise NotImplementedError, "should be implemented in subclass"
-  end
-  def if_success(&block); on_success(&block); end
-  def when_success(&block); on_success(&block); end
-  def on_ok(&block); on_success(&block); end
-  def if_ok(&block); on_success(&block); end
-  def when_ok(&block); on_success(&block); end
-  def on_successful(&block); on_success(&block); end
-  def if_successful(&block); on_success(&block); end
-  def when_successful(&block); on_success(&block); end
-
-  def on_failure(&block)
-    raise NotImplementedError, "should be implemented in subclass"
-  end
-  def if_failure(&block); on_failure(&block); end
-  def when_failure(&block); on_failure(&block); end
-  def on_bad(&block); on_failure(&block); end
-  def if_bad(&block); on_failure(&block); end
-  def when_bad(&block); on_failure(&block); end
-  def on_failed(&block); on_failure(&block); end
-  def if_failed(&block); on_failure(&block); end
-  def when_failed(&block); on_failure(&block); end
+    def __map(callable)
+      raise NotImplementedError, "should be implemented in subclass"
+    end
 
-  NIL_SUCCESS = Success.new(nil)
-  NIL_FAILURE = Failure.new(nil)
+    def __flat_map(callable)
+      raise NotImplementedError, "should be implemented in subclass"
+    end
+
+    def __flat_map_error(callable)
+      raise NotImplementedError, "should be implemented in subclass"
+    end
+
+    def __on_success(callable)
+      raise NotImplementedError, "should be implemented in subclass"
+    end
+
+    def __on_failure(callable)
+      raise NotImplementedError, "should be implemented in subclass"
+    end
+
+    def callable_from_args(positional, block)
+      if block
+        if positional
+          raise ArgumentError, "expected _either_ a callable or a block argument, but _both_ were given"
+        else
+          block
+        end
+      else
+        if positional
+          positional
+        else
+          raise ArgumentError, "expected either a callable or a block argument, but neither were given"
+        end
+      end
+    end
 end

data/lib/resonad/version.rb

@@ -1,3 +1,3 @@
 class Resonad
-  VERSION = '1.3.0'
+  VERSION = '1.4.0'
 end

data/resonad.gemspec

@@ -23,4 +23,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", ">= 1.15"
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "gem-release", "~> 2.1"
+  spec.add_development_dependency "byebug"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: resonad
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.4.0
 platform: ruby
 authors:
 - Tom Dalling
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-07-12 00:00:00.000000000 Z
+date: 2020-11-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Objects that represent success or failure
 email:
 - tom@tomdalling.com
@@ -92,8 +106,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.7
+rubygems_version: 3.0.8
 signing_key: 
 specification_version: 4
 summary: Objects that represent success or failure