ruby-monads 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 20b2534e81fe4b81311ea0dc9b9ab696edab9a2cffc124ef922bb9d26edc87b8
-  data.tar.gz: 050a8dea7bfeb6dea6b6635c90ce216968208d73346023440ef4410cbdd00e62
+  metadata.gz: 1af43d29c4276218767541b961ca19fb65e5f48c35cfd880f33fd47a23a5c7e4
+  data.tar.gz: 3da1575ae115a6c572720550a4b08b651ceaa04b75d43a9d643f8658e3b28f9a
 SHA512:
-  metadata.gz: 0a8ce58d40d7c361e1e860c1700b5edbbbb927698449ecddc412fdd3ce6f3bc3f3bd1e923ef62ab33fd7f92e13fc3b7f1afb7e7d7cfb79337bda0cfcb9aacf19
-  data.tar.gz: 604d7fddc645a0e08591d192736339eacc17174a39f3d4b58500c4aaa9df19b02c5917cd7cc6f0cfcfeedb5ee62ca2673fd611e00216d603671ec6e174ec00ee
+  metadata.gz: 53328e008e31ecb7d4f08323e1c6665d7e93fbf72224cf5ee29b573e88bba14b4c67b9e740948ecd458281b48269589a8cd903144eb3ec2110981b1430e8e13d
+  data.tar.gz: e33053dfad28ca2ba867061f35121e139c7aef399971fa8c92128840d16951c636526dbf8979cae712dc37e9a0befd70cd061f2b6d357bddd3181933bf892a6a

data/README.md

@@ -30,20 +30,41 @@ The maybe monad returns one of the following classes, wether it wraps a value or
 #### Examples
 
 ```ruby
-just = Maybe.unit("Hello, World!")     # => #<Monads::Just @value="Hello, World!">
-nothing = Maybe.unit(nil)              # => #<Monads::Nothing>
-
-just.upcase                            # => #<Monads::Just @value="HELLO, WORLD!">
-just.upcase.split.unwrap([])           # => ["HELLO,", "WORLD!"]
-just.bind { |v| Maybe.unit(nil) }      # => #<Monads::Nothing>
-just.fmap { |v| v.gsub(/\w/, "*") }    # => #<Monads::Just @value="*****, *****!">
-Maybe.unit(just).join                  # => #<Monads::Just @value="Hello, World!">
-
-nothing.upcase                         # => #<Monads::Nothing>
-nothing.upcase.split.unwrap([])        # => []
-nothing.bind { |v| just }              # => #<Monads::Nothing>
-nothing.fmap { |v| v.gsub(/\w/, "*") } # => #<Monads::Nothing>
-Maybe.unit(nothing).join               # => #<Monads::Nothing>
+Maybe.unit("Hello, World!")                                # => #<Monads::Just @value="Hello, World!">
+Maybe.unit(nil)                                            # => #<Monads::Nothing>
+
+Maybe.unit("Hello, World!").upcase                         # => #<Monads::Just @value="HELLO, WORLD!">
+Maybe.unit("Hello, World!").upcase.split.unwrap([])        # => ["HELLO,", "WORLD!"]
+Maybe.unit("Hello, World!").bind { |v| Maybe.unit(nil) }   # => #<Monads::Nothing>
+Maybe.unit("Hello, World!").fmap { |v| v.gsub(/\w/, "*") } # => #<Monads::Just @value="*****, *****!">
+Maybe.unit(Maybe.unit("Hello, World!")).join               # => #<Monads::Just @value="Hello, World!">
+
+Maybe.unit(nil).upcase                                     # => #<Monads::Nothing>
+Maybe.unit(nil).upcase.split.unwrap([])                    # => []
+Maybe.unit(nil).bind { |v| Maybe.unit("Hello, World!") }   # => #<Monads::Maybe.unit(nil)>
+Maybe.unit(nil).fmap { |v| v.gsub(/\w/, "*") }             # => #<Monads::Nothing>
+Maybe.unit(Maybe.unit(nil)).join                           # => #<Monads::Nothing>
+```
+
+### Result
+
+The result monad returns one of the following classes, wether it wraps an error or not:
+
+- `Result.unit(42)` returns an instance of `Success` wrapping the `42` value
+- `Result.unit(StandardError.new)` returns an instance of `Failure` wrapping the given error
+
+#### Examples
+
+```ruby
+Result.unit("Hello, World!")             # => #<Monads::Success @value="Hello, World!">
+Result.unit(StandardError.new("Wrong!")) # => #<Monads::Failure @value=#<StandardError: Wrong!>>
+
+Result
+  .unit("Hello, World!")                 # => #<Monads::Success @value="Hello, World!">
+  .upcase                                # => #<Monads::Success @value="HELLO, WORLD!">
+  .even                                  # => #<Monads::Failure @value=#<NoMethodError: undefined method `even?' for "HELLO, WORLD!":String>>
+  .split                                 # => #<Monads::Failure @value=#<NoMethodError: undefined method `even?' for "HELLO, WORLD!":String>>
+  .unwrap("default")                     # "default"
 ```
 
 ## Why this gem

data/lib/monads/result.rb

@@ -6,7 +6,13 @@ module Monads
 
     # unit :: a -> M a
     def self.unit(value)
-      value.is_a?(FAILURE_TRIGGER) ? Failure.new(value) : Success.new(value)
+      if value.is_a?(FAILURE_TRIGGER) || value.is_a?(Failure)
+        Failure.new(value)
+      else
+        Success.new(value)
+      end
+    rescue => error
+      Failure.new(error)
     end
 
     # bind :: (a -> M b) -> M a -> M b

data/ruby-monads.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = "ruby-monads"
-  s.version = "0.1.0"
+  s.version = "0.2.0"
   s.summary = "Some common monads"
   s.description = "Simple and minimalist ruby implementation of some common monads"
   s.author = "Guillaume BOUDON"

data/test/result_test.rb

@@ -0,0 +1,63 @@
+print "\n\"Result\" monad test suite"
+
+setup do
+  [Success.new(42), Failure.new(StandardError.new("Wrong!"))]
+end
+
+test "Result::new" do
+  assert_raise NoMethodError do Result.new(42) end
+
+  assert_raise TypeError do Success.new(StandardError.new) end
+  assert Success.new(42).is_a?(Success)
+
+  assert_raise TypeError do Failure.new(42) end
+  assert Failure.new(StandardError.new).is_a?(Failure)
+end
+
+test "Result::unit" do |success, failure|
+  assert success.is_a?(Result)
+  assert success.is_a?(Success)
+  assert !success.is_a?(Failure)
+
+  assert failure.is_a?(Result)
+  assert !failure.is_a?(Success)
+  assert failure.is_a?(Failure)
+
+  assert Result.unit(success).is_a?(Success)
+  assert Result.unit(failure).is_a?(Failure)
+end
+
+test "Result#bind" do |success, failure|
+  assert success.bind { |v| Result.unit(v / 2) }.is_a?(Success)
+  assert success.bind { |v| Result.unit(v / 0) }.is_a?(Failure)
+  assert success.bind { |v| v / 0 }.is_a?(Failure)
+
+  assert failure.bind { |v| Result.unit(42) }.is_a?(Failure)
+  assert failure.bind { |v| Result.unit(StandardError.new) }.is_a?(Failure)
+  assert failure.bind { |v| v / 2 }.is_a?(Failure)
+end
+
+test "Result#fmap" do |success, failure|
+  assert success.fmap(&:even?).is_a?(Success)
+  assert success.fmap { |v| v / 0 }.is_a?(Failure)
+
+  assert failure.fmap(&:even?).is_a?(Failure)
+  assert failure.fmap { |v| v / 0 }.is_a?(Failure)
+end
+
+test "Result#join" do |success, failure|
+  assert_equal Result.unit(success).join.unwrap("default"), 42
+  assert_equal Result.unit(failure).join.unwrap("default"), "default"
+end
+
+test "Result#unwrap" do |success, failure|
+  assert_equal success.unwrap("default"), 42
+  assert_equal success.unwrap(nil), 42
+  assert_equal failure.unwrap("default"), "default"
+  assert_equal failure.unwrap(nil), nil
+end
+
+test "Result accepts methods chaining" do |success, failure|
+  assert_equal success.next.div(13).to_f.unwrap(1.0), 3.0
+  assert_equal failure.next.div(13).to_f.unwrap(1.0), 1.0
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-monads
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Guillaume BOUDON
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-08-07 00:00:00.000000000 Z
+date: 2020-08-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cutest
@@ -48,6 +48,7 @@ files:
 - ruby-monads.gemspec
 - test/helper.rb
 - test/maybe_test.rb
+- test/result_test.rb
 homepage: https://github.com/guillaumeboudon/ruby-monads
 licenses:
 - MIT