ruby-monads 0.3.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 55c6088fd478bb54ff23ab74a4fb4ec917c6eaebec241cc991ee1077ae247c85
-  data.tar.gz: ebe2892a398cade5dd74cef9ff9e2864739e6014e0007a078de690df0063282c
+  metadata.gz: dd389d5593547aeb5a98a2402ea559b823c6e02ad46e78b70ccb62749cfccc4f
+  data.tar.gz: 92e10a0337e1a48fb836bdcc0ee1817b39eae244196ab690f5cb8c0a8e880886
 SHA512:
-  metadata.gz: b06c423bfec4694a595b56c090aa55777d2616d09e586acb4b7a3cb88ef9f447839da796f35bf1d3167e3cab7057c41baab9c3119a6fcd813d858a5539e874a7
-  data.tar.gz: 573f65c886609153eef163992f5212cad6cc63b70aba4386be4e74ecd2623d3d0605903ba8258768c7b130e50d41dd2aca2db35406d14a75a165695745d429d4
+  metadata.gz: 8a05486f93f6600331a38debb0a141dee45e863edd58063f78eebc691f8d97dc8a6f184f213fe058c5f8cab2c88dcf737754d0cbcc7855943de2b228f5cd0212
+  data.tar.gz: 53653541065be86d29394279b76fe17aa29d6685b246eb70d85b9adda7293201c2a0f2047bd2e8d189bd3c2367fee3addcf1cda3f8bfbcbd50f5b2d18170e8b0

data/.gems

@@ -1 +1,3 @@
 cutest -v 1.2.3
+rubocop -v 1.68
+standard -v 1.42.1

data/.rubocop.yml

@@ -0,0 +1,4 @@
+require: "standard"
+
+inherit_gem:
+  standard: "config/ruby-3.0.yml"

data/README.md

@@ -24,43 +24,43 @@ include Monads
 
 The maybe monad returns one of the following classes, wether it wraps a value or not:
 
-- `Maybe.unit(42)` returns an instance of `Just` wrapping the `42` value
-- `Maybe.unit(nil)` returns an instance of `Nothing` wrapping no value
+- `Maybe.wrap(42)` returns an instance of `Just` wrapping the `42` value
+- `Maybe.wrap(nil)` returns an instance of `Nothing` wrapping no value
 
 #### Examples
 
 ```ruby
-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>
+Maybe.wrap("Hello, World!")                                # => #<Monads::Just @value="Hello, World!">
+Maybe.wrap(nil)                                            # => #<Monads::Nothing>
+
+Maybe.wrap("Hello, World!").upcase                         # => #<Monads::Just @value="HELLO, WORLD!">
+Maybe.wrap("Hello, World!").upcase.split.unwrap([])        # => ["HELLO,", "WORLD!"]
+Maybe.wrap("Hello, World!").bind { |v| Maybe.wrap(nil) }   # => #<Monads::Nothing>
+Maybe.wrap("Hello, World!").fmap { |v| v.gsub(/\w/, "*") } # => #<Monads::Just @value="*****, *****!">
+Maybe.wrap(Maybe.wrap("Hello, World!")).join               # => #<Monads::Just @value="Hello, World!">
+
+Maybe.wrap(nil).upcase                                     # => #<Monads::Nothing>
+Maybe.wrap(nil).upcase.split.unwrap([])                    # => []
+Maybe.wrap(nil).bind { |v| Maybe.wrap("Hello, World!") }   # => #<Monads::Maybe.wrap(nil)>
+Maybe.wrap(nil).fmap { |v| v.gsub(/\w/, "*") }             # => #<Monads::Nothing>
+Maybe.wrap(Maybe.wrap(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
+- `Result.wrap(42)` returns an instance of `Success` wrapping the `42` value
+- `Result.wrap(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.wrap("Hello, World!")             # => #<Monads::Success @value="Hello, World!">
+Result.wrap(StandardError.new("Wrong!")) # => #<Monads::Failure @value=#<StandardError: Wrong!>>
 
 Result
-  .unit("Hello, World!")                 # => #<Monads::Success @value="Hello, World!">
+  .wrap("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>>
@@ -77,7 +77,7 @@ This gem is heavily inspired by the following monads implementations:
 These gems, and many others are really great, and it was very instructive to learn about this topic in my beloved language. However, after reading a lot of implementations and articles, I had a clear opinion of how I wanted it:
 
 - _Minimalist:_ as simple an lightweight as possible
-- _Respectful of uses:_ respectful of the usual terms ([Monad (functional programming)](https://en.wikipedia.org/wiki/Monad_(functional_programming))), like `Maybe`, `unit`, `bind`, `join`, etc.
+- _Respectful of uses:_ respectful of the usual terms ([Monad (functional programming)](https://en.wikipedia.org/wiki/Monad_(functional_programming))), like `Maybe`, `wrap`, `bind`, `join`, etc.
 - _Vanilla Ruby syntax:_ I love some of the abstractions I discovered (`>=` operator, `Just(value)` syntax). However, I also love vanilla Ruby. So, I wanted to target new methods and abstractions, not new syntaxes comming from other languages.
 
 ## Tests

data/lib/ruby-monads/maybe.rb

@@ -2,9 +2,9 @@ module Monads
   class Maybe
     include Monads::Monad
 
-    # unit :: a -> M a
-    def self.unit(value)
-      value.nil? || value.is_a?(Nothing) ? Nothing.new : Just.new(value)
+    # wrap :: a -> M a
+    def self.wrap(value)
+      (value.nil? || value.is_a?(Nothing)) ? Nothing.new : Just.new(value)
     end
 
     # bind :: (a -> M b) -> M a -> M b

data/lib/ruby-monads/monad.rb

@@ -13,14 +13,14 @@ module Monads
     # fmap :: (a -> b) -> M a -> M b
     def fmap(&block)
       bind do |value|
-        self.class.unit(block.call(value))
+        self.class.wrap(block.call(value))
       end
     end
 
     # join :: M (M a) -> M a
     def join
       value = @value.is_a?(monad_type) ? @value.unwrap(nil) : @value
-      monad_type.unit(value)
+      monad_type.wrap(value)
     end
 
     def method_missing(method, *args, &block)

data/lib/ruby-monads/result.rb

@@ -4,8 +4,8 @@ module Monads
 
     FAILURE_TRIGGER = StandardError
 
-    # unit :: a -> M a
-    def self.unit(value)
+    # wrap :: a -> M a
+    def self.wrap(value)
       if value.is_a?(FAILURE_TRIGGER) || value.is_a?(Failure)
         Failure.new(value)
       else

data/ruby-monads.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = "ruby-monads"
-  s.version = "0.3.0"
+  s.version = "1.0.0"
   s.summary = "Some common monads"
   s.description = "Simple and minimalist ruby implementation of some common monads"
   s.author = "Guillaume BOUDON"
@@ -11,4 +11,6 @@ Gem::Specification.new do |s|
   s.files = `git ls-files`.split("\n")
 
   s.add_development_dependency "cutest", "~> 1.2", ">= 1.2.3"
+  s.add_development_dependency "rubocop", "~> 1", ">= 1.68"
+  s.add_development_dependency "standard", "~> 1.42", ">= 1.42.1"
 end

data/test/helper.rb

@@ -1,3 +1,3 @@
-require_relative "../lib/monads"
+require_relative "../lib/ruby-monads"
 
 include Monads

data/test/maybe_test.rb

@@ -1,7 +1,7 @@
 print "\n\"Maybe\" monad test suite"
 
 setup do
-  [Maybe.unit("Hello, World!"), Maybe.unit(nil)]
+  [Maybe.wrap("Hello, World!"), Maybe.wrap(nil)]
 end
 
 test "Maybe::new" do
@@ -14,7 +14,7 @@ test "Maybe::new" do
   assert Nothing.new.is_a?(Nothing)
 end
 
-test "Maybe::unit" do |just, nothing|
+test "Maybe::wrap" do |just, nothing|
   assert just.is_a?(Maybe)
   assert just.is_a?(Just)
   assert !just.is_a?(Nothing)
@@ -23,17 +23,17 @@ test "Maybe::unit" do |just, nothing|
   assert !nothing.is_a?(Just)
   assert nothing.is_a?(Nothing)
 
-  assert Maybe.unit(just).is_a?(Just)
-  assert Maybe.unit(nothing).is_a?(Nothing)
+  assert Maybe.wrap(just).is_a?(Just)
+  assert Maybe.wrap(nothing).is_a?(Nothing)
 end
 
 test "Maybe#bind" do |just, nothing|
-  assert just.bind { |v| Maybe.unit(v.to_sym) }.is_a?(Just)
-  assert just.bind { |v| Maybe.unit(nil) }.is_a?(Nothing)
+  assert just.bind { |v| Maybe.wrap(v.to_sym) }.is_a?(Just)
+  assert just.bind { |v| Maybe.wrap(nil) }.is_a?(Nothing)
   assert_raise TypeError do just.bind { |v| v.to_sym } end
 
-  assert nothing.bind { |v| Maybe.unit(42) }.is_a?(Nothing)
-  assert nothing.bind { |v| Maybe.unit(nil) }.is_a?(Nothing)
+  assert nothing.bind { |v| Maybe.wrap(42) }.is_a?(Nothing)
+  assert nothing.bind { |v| Maybe.wrap(nil) }.is_a?(Nothing)
   assert nothing.bind { |v| v.to_sym }.is_a?(Nothing)
 end
 
@@ -46,8 +46,8 @@ test "Maybe#fmap" do |just, nothing|
 end
 
 test "Maybe#join" do |just, nothing|
-  assert_equal Maybe.unit(just).join.unwrap("default"), "Hello, World!"
-  assert_equal Maybe.unit(nothing).join.unwrap("default"), "default"
+  assert_equal Maybe.wrap(just).join.unwrap("default"), "Hello, World!"
+  assert_equal Maybe.wrap(nothing).join.unwrap("default"), "default"
 end
 
 test "Maybe#unwrap" do |just, nothing|

data/test/result_test.rb

@@ -14,7 +14,7 @@ test "Result::new" do
   assert Failure.new(StandardError.new).is_a?(Failure)
 end
 
-test "Result::unit" do |success, failure|
+test "Result::wrap" do |success, failure|
   assert success.is_a?(Result)
   assert success.is_a?(Success)
   assert !success.is_a?(Failure)
@@ -23,17 +23,17 @@ test "Result::unit" do |success, failure|
   assert !failure.is_a?(Success)
   assert failure.is_a?(Failure)
 
-  assert Result.unit(success).is_a?(Success)
-  assert Result.unit(failure).is_a?(Failure)
+  assert Result.wrap(success).is_a?(Success)
+  assert Result.wrap(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| Result.wrap(v / 2) }.is_a?(Success)
+  assert success.bind { |v| Result.wrap(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| Result.wrap(42) }.is_a?(Failure)
+  assert failure.bind { |v| Result.wrap(StandardError.new) }.is_a?(Failure)
   assert failure.bind { |v| v / 2 }.is_a?(Failure)
 end
 
@@ -46,8 +46,8 @@ test "Result#fmap" do |success, 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"
+  assert_equal Result.wrap(success).join.unwrap("default"), 42
+  assert_equal Result.wrap(failure).join.unwrap("default"), "default"
 end
 
 test "Result#unwrap" do |success, failure|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-monads
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Guillaume BOUDON
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-09-21 00:00:00.000000000 Z
+date: 2024-11-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cutest
@@ -30,6 +30,46 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.2.3
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.68'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.68'
+- !ruby/object:Gem::Dependency
+  name: standard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.42'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.42.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.42'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.42.1
 description: Simple and minimalist ruby implementation of some common monads
 email: guillaumeboudon@gmail.com
 executables: []
@@ -38,6 +78,7 @@ extra_rdoc_files: []
 files:
 - ".gems"
 - ".gitignore"
+- ".rubocop.yml"
 - LICENSE
 - Makefile
 - README.md
@@ -68,7 +109,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: Some common monads