ytry 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 445fb840f8d15382ce1b280cdc6f746b907e2dfb
-  data.tar.gz: 559d814425ba8e70f0e23932890922d99a5393d3
+  metadata.gz: 6575212d45e0fb109f44a9da7cba53ad23693ee7
+  data.tar.gz: 7054016b7dfb31dcff32878f13ae6ef30e0e9b1c
 SHA512:
-  metadata.gz: e4dcc9c8e5518b8ed3ee38e9d2c6fed5c858f6bcb64dcb72adc86e6bc61950b211d4de880cb8ed0bbbb9f79f589ea9709fda6130bfd7499599fb16c5368c4d33
-  data.tar.gz: 3d65b7ee4d84e21b90f42c84ba11a91cc27f8d26bfa3235bb9377823dfa97b7d712ad7ff74a1866b3c945b834f6daaa57307683fc3defc3e75628f20025c32d6
+  metadata.gz: 7e1deff71f7aad49b3b29832fca250bcfb5b05778cb6c05111dd5dd13289c4b23857bc79b8901c420bc023a661973d0ca30b9a791d8c5b85df1d5d7b4be5037d
+  data.tar.gz: b519003d0a36612a5e70610b4a5369a7c1f92c75359b56739980ad0e5ff381fcce3aaafd139f118c8d869bce3e5fc36868dc58d840a15025eef56d85577d2290

data/README.md

@@ -82,6 +82,44 @@ Using Try instead of rescue blocks can make your software both clearer and safer
 - privileges method chaining thus reducing the need for auxiliary variables to store intermediate results in a computation
 - encourages programming towards immutability, where the data is transformed rather than mutated in place.
 
+## Advanced Usage
+### #reduce
+Given a Try instance `try`, a value `c` and a lambda `f`,
+```
+try.reduce(c, &f)
+```
+returns `f.(c, try)` if `try` is a `Success` AND the evaluation of the lambda `f` did not throw any error, it returns `c` otherwise.
+
+This is a shortcut to
+```
+try.map{|v| f.(c,v)}.get_or_else {c}
+```
+
+
+### #flatten
+When dealing with nested `Try`s we can use flatten to reduce the level of nesting
+```
+success = Try{:ok}
+failure = Try{fail}
+Try{success}.flatten # Success(:ok)
+Try{failure}.flatten # Failure(RuntimeError)
+```
+
+### Interoperability with Array-like obects
+Because of it's ary-like nature, instances of `Try` play well with Array instances. In particular, flattening an Array of `Try`s is equivalent to filtering out the `Failures` from the array and then calling #get on the Success instances
+```
+(1..4).map{|v| Try{v}.select(&:odd?)}
+      .flatten # [1, 3]
+```
+Behind the scenes `Array#flatten` is iterating over the collection and concatenating the ary-representation of each element.
+Now `Failure#to_ary` returns `[]`, while `Success#to_ary` returns `[v]` - where `v` is the value wrapped by Success - and that does the trick.
+
+We can squeeze the code listed above even more with `Array#flat_map`
+```
+(1..4).flat_map{|v| Try{v}.select(&:odd?)} # [1, 3]
+```
+Again, there is no magic behind this behaviour, we are just exploiting Ruby's duck typing.
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/lib/ytry.rb

@@ -24,14 +24,30 @@ module Ytry
     end
     def each
       return enum_for(__method__) unless block_given?
-      yield self.get unless empty?
+      Try { yield self.get unless empty? }
       return self
     end
-    %i(map select reject collect collect_concat).each do |method|
-      define_method method, ->(&block) {
-        block or return enum_for(method)
-        self.empty? ? self : Try.ary_to_type(Try{super(&block)}.flatten)
-      }
+    alias_method :on_success, :each
+    def on_failure
+      return enum_for(__method__) unless block_given?
+      return self
+    end
+    def map &block
+      block or return enum_for(__method__)
+      self.empty? ? self : Try{block.call(self.get)}
+    end
+    alias_method :collect, :map
+    def select &block
+      block or return enum_for(__method__)
+      return self if empty?
+      predicate = Try{ block.call(self.get) }
+      return predicate if predicate.empty?
+      predicate.get ? self : Try.ary_to_type([])
+    end
+    def reject &block
+      if block_given? then select {|v| ! block.call(v)}
+      else enum_for(__method__)
+      end
     end
     def flat_map &block
       block or return enum_for(method)
@@ -40,12 +56,19 @@ module Ytry
       return wrapped_result if (!wrapped_result.empty? && !wrapped_result.get.respond_to?(:to_ary))
       Try.ary_to_type(wrapped_result.flatten)
     end
-    def grep(pattern, &block)
-      self.empty? ? self : Try.ary_to_type(Try{super}.flatten)
+    alias_method :collect_concat, :flat_map
+    def grep pattern
+      return self if self.empty?
+      match = Try {
+        (pattern === self.get) ? self.get : (raise RuntimeError.new("Element not found"))
+      }
+      block_given? ? match.map{|v| yield v} : match
     end
-    def flatten
-      return self if empty?
-      Try.ary_to_type self.get
+    def flatten level = 1
+      level.times.reduce(self) { |current, _|
+        break(current) if current.empty?
+        Try.ary_to_type current.get
+      }
     end
     def zip *others
       Try.zip(self, *others)
@@ -55,8 +78,12 @@ module Ytry
     end
     def or_else
       return self unless empty?
-      other = yield
-      other.is_a?(Try) ? other : raise(Try.invalid_argument('Block should evaluate to an Try', other))
+      candidate = Try{ yield }
+      if (!candidate.empty? && !candidate.get.is_a?(Try))
+        raise(Try.invalid_argument('Block should evaluate to an instance of Try', candidate.get))
+      else
+        candidate.flatten
+      end
     end
     def get_or_else
       raise ArgumentError, 'missing block' unless block_given?
@@ -88,6 +115,10 @@ module Ytry
       raise ArgumentError, 'missing block' unless block_given?
       self
     end
+    def recover_with &block
+      raise ArgumentError, 'missing block' unless block_given?
+      self
+    end
   end
   class Failure
     include Try
@@ -105,10 +136,23 @@ module Ytry
     def === other
       other.is_a?(Failure) && self.error === other.error
     end
+    def on_failure
+      return enum_for(__method__) unless block_given?
+      Try { yield @error }
+      return self
+    end
     def recover &block
       raise ArgumentError, 'missing block' unless block_given?
       candidate = Success.new(@error).map &block
       (!candidate.empty? && candidate.get.nil?) ? self : candidate
     end
+    def recover_with &block
+      candidate = self.recover(&block)
+      if (!candidate.empty? && !candidate.get.is_a?(Try))
+        raise(Try.invalid_argument('Block should evaluate to an instance of Try', candidate.get))
+      else
+        candidate.flatten
+      end
+    end
   end
 end

data/lib/ytry/version.rb

@@ -1,3 +1,3 @@
 module Ytry
-  VERSION = "1.0.0"
+  VERSION = "2.0.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ytry
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0
 platform: ruby
 authors:
 - lorenzo.barasti
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-07-03 00:00:00.000000000 Z
+date: 2016-08-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler