ribimaybe 0.0.12 → 0.0.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5eaabf0383c05d88afb353a4ed3dbd0d9a6c0894
-  data.tar.gz: 9271691363379c9749a5f5f7d9376e2e54b9f358
+  metadata.gz: c4f36f13ff02dcf449662d3d89acdce59f781329
+  data.tar.gz: 09a060eebd6164be01a68f33d6820660a2afb7eb
 SHA512:
-  metadata.gz: 8157d075f048b7b0f1af57cbc0b936b596ed8eb6c7d25c3a19455cac0b9ddfea9e8d60f49a5b7ae5331d8e4ec899e0b1ee88a3afe962b52e35542bba404ca552
-  data.tar.gz: 99921ff3c5289207a063985b424bc038b5a2493f7c6112ec730a28f4b561f1b2228582bd99208ef8a099ceab9ed132791707735da2a90a54ba4af3bf605947df
+  metadata.gz: e99de225be69caf575dabfb961167d1b642dd2e497371ef2a301276d72529f70e7e63abe21f55c3f77ba14d523c2b2b15f5bb4a8e34107d9fdc1510bb6c0e479
+  data.tar.gz: a57acc14c7af6109c870efd22a31a9e2eec688aa2b9e038ef11f8466d2cfa8ee9a7028ae3b9ac520d0f785e2dba5812528f0ccbf2479f7552c13b0046a705a9d

data/README.md

@@ -91,7 +91,15 @@ end # => Just(42)
 Nothing.bind do |x|
   rturn(x * x)
 end # => Nothing
+
+# We even have >= but you need to pass a Proc or a lambda.
+Just(42) >= -> (x) do
+  rturn(x - 21) >= -> (y) do
+    if x * x > 100 then rturn(y) else rturn(x) end
+  end
+end
 ```
+
 ## Contributing
 
 1. Fork it

data/lib/ribimaybe.rb

@@ -59,9 +59,13 @@ module Ribimaybe
       # No operation. Always returns Nothing.
       #
       Contract Proc => Nothing
-      def self.bind(&_)
+      def self.bind(fn = nil, &_)
         self
       end
+
+      class << self
+        alias_method :>=, :bind
+      end
     end
 
     class Just
@@ -165,9 +169,11 @@ module Ribimaybe
       # end # => Just(2)
       #
       Contract Proc => Or[Nothing, Just]
-      def bind(&fn)
-        fn.curry.(@value)
+      def bind(fn = nil, &block)
+        (fn || block).curry.(@value)
       end
+
+      alias_method :>=, :bind
     end
 
     # Converts nil to Nothing or lifts value into a Just. Accepts a optional

data/lib/version.rb

@@ -1,3 +1,3 @@
 module Ribimaybe
-  VERSION = "0.0.12"
+  VERSION = "0.0.13"
 end

data/spec/applicative_functor_spec.rb

@@ -21,81 +21,83 @@ describe "Applicative Instance" do
     ->(x){ ->(y) { x } }.(SecureRandom.base64(1000))
   end
 
-  # pure id <*> v = v
-  describe "identity" do
-    context "when i have nothing" do
-      it do
-        expect(pure(&id).apply(Nothing)).to eq(Nothing)
+  [:apply, :>>].each do |m|
+    # pure id <*> v = v
+    describe "identity" do
+      context "when i have nothing" do
+        it do
+          expect(pure(&id).public_send(m, Nothing)).to eq(Nothing)
+        end
       end
-    end
 
-    context "when i have just :x" do
-      it do
-        expect(pure(&id).apply(pure(:x))).to eq(pure(:x))
+      context "when i have just :x" do
+        it do
+          expect(pure(&id).public_send(m, pure(:x))).to eq(pure(:x))
+        end
       end
     end
-  end
 
-  # pure (.) <*> u <*> v <*> w = u <*> (v <*> w)
-  describe "composition" do
-    context "when i have nothing" do
-      it do
-        lhs = pure(&dot).apply(pure(&f)).apply(pure(&g)).apply(Nothing)
-        rhs = pure(&f).apply(pure(&g).apply(Nothing))
-        expect(lhs).to eq(rhs)
+    # pure (.) <*> u <*> v <*> w = u <*> (v <*> w)
+    describe "composition" do
+      context "when i have nothing" do
+        it do
+          lhs = pure(&dot).public_send(m, pure(&f)).public_send(m, pure(&g)).public_send(m, Nothing)
+          rhs = pure(&f).public_send(m, pure(&g).public_send(m, Nothing))
+          expect(lhs).to eq(rhs)
+        end
       end
-    end
 
-    context "when i have just :x" do
-      it do
-        lhs = pure(&dot).apply(pure(&f)).apply(pure(&g)).apply(pure(:x))
-        rhs = pure(&f).apply(pure(&g).apply(pure(:x)))
-        expect(lhs).to eq(rhs)
+      context "when i have just :x" do
+        it do
+          lhs = pure(&dot).public_send(m, pure(&f)).public_send(m, pure(&g)).public_send(m, pure(:x))
+          rhs = pure(&f).public_send(m, pure(&g).public_send(m, pure(:x)))
+          expect(lhs).to eq(rhs)
+        end
       end
     end
-  end
 
-  # pure f <*> pure x = pure (f x)
-  describe "homomorphism" do
-    context "when i have nothing" do
-      it do
-        expect(pure(&f).apply(Nothing)).to eq(Nothing)
+    # pure f <*> pure x = pure (f x)
+    describe "homomorphism" do
+      context "when i have nothing" do
+        it do
+          expect(pure(&f).public_send(m, Nothing)).to eq(Nothing)
+        end
       end
-    end
 
-    context "when i have just :x" do
-      it do
-        expect(pure(&f).apply(pure(:x))).to eq(pure(f.(:x)))
+      context "when i have just :x" do
+        it do
+          expect(pure(&f).public_send(m, pure(:x))).to eq(pure(f.(:x)))
+        end
       end
     end
-  end
 
-  # u <*> pure y = pure ($ y) <*> u
-  describe "interchange" do
-    context "when i have nothing" do
-      it do
-        expect(pure(&f).apply(Nothing)).to eq(pure(&ap.(f)).apply(Nothing))
+    # u <*> pure y = pure ($ y) <*> u
+    describe "interchange" do
+      context "when i have nothing" do
+        it do
+          expect(pure(&f).public_send(m, Nothing)).to eq(pure(&ap.(f)).public_send(m, Nothing))
+        end
       end
-    end
 
-    context "when i have just :x" do
-      it do
-        expect(pure(&f).apply(pure(:x))).to eq(pure(&ap.(f)).apply(pure(:x)))
+      context "when i have just :x" do
+        it do
+          expect(pure(&f).public_send(m, pure(:x))).to eq(pure(&ap.(f)).public_send(m, pure(:x)))
+        end
       end
     end
-  end
 
-  # fmap f x = pure f <*> x
-  describe "map" do
-    context "when i have nothing" do
-      it do
-        expect(Nothing.map(&f)).to eq(pure(&f).apply(Nothing))
+    # fmap f x = pure f <*> x
+    describe "map" do
+      context "when i have nothing" do
+        it do
+          expect(Nothing.map(&f)).to eq(pure(&f).public_send(m, Nothing))
+        end
       end
-    end
 
-    context "when i have just :x" do
-      it do
-        expect(Just(:x).map(&f)).to eq(pure(&f).apply(Just(:x)))
+      context "when i have just :x" do
+        it do
+          expect(Just(:x).map(&f)).to eq(pure(&f).public_send(m, Just(:x)))
+        end
       end
     end
   end

data/spec/monad_spec.rb

@@ -17,51 +17,53 @@ describe "Monad Instance" do
     ->(x){ ->(y) { rturn(x) } }.(SecureRandom.base64(1000))
   end
 
-  # return a >>= f = f a
-  describe "left identity" do
-    context "when i have nothing" do
-      it do
-        expect(Nothing.bind(&lifted_id)).to eq(Nothing)
+  [:bind, :>=].each do |m|
+    # return a >>= f = f a
+    describe "left identity" do
+      context "when i have nothing" do
+        it do
+          expect(Nothing.public_send(m, &lifted_id)).to eq(Nothing)
+        end
       end
-    end
 
-    context "when i have just :x" do
-      it do
-        expect(rturn(:x).bind(&lifted_id)).to eq(lifted_id.(:x))
+      context "when i have just :x" do
+        it do
+          expect(rturn(:x).public_send(m, &lifted_id)).to eq(lifted_id.(:x))
+        end
       end
     end
-  end
 
-  # m >>= return = m
-  describe "right identity" do
-    context "when i have nothing" do
-      it do
-        expect(Nothing.bind(&lifted_id)).to eq(Nothing)
+    # m >>= return = m
+    describe "right identity" do
+      context "when i have nothing" do
+        it do
+          expect(Nothing.public_send(m, &lifted_id)).to eq(Nothing)
+        end
       end
-    end
 
-    context "when i have just :x" do
-      it do
-        expect(Just(:x).bind(&lifted_id)).to eq(Just(:x))
+      context "when i have just :x" do
+        it do
+          expect(Just(:x).public_send(m, &lifted_id)).to eq(Just(:x))
+        end
       end
     end
-  end
 
-  # (m >>= f) >>= g = m >>= (\x -> f x >>= g)
-  describe "associativity" do
-    context "when i have nothing" do
-      it do
-        lhs = Nothing.bind(&f).bind(&g)
-        rhs = Nothing.bind { |x| f.(x).bind(&g) }
-        expect(lhs).to eq(rhs)
+    # (m >>= f) >>= g = m >>= (\x -> f x >>= g)
+    describe "associativity" do
+      context "when i have nothing" do
+        it do
+          lhs = Nothing.public_send(m, &f).public_send(m, &g)
+          rhs = Nothing.bind { |x| f.(x).public_send(m, &g) }
+          expect(lhs).to eq(rhs)
+        end
       end
-    end
 
-    context "when i have just :x" do
-      it do
-        lhs = Just(:x).bind(&f).bind(&g)
-        rhs = Just(:x).bind { |x| f.(x).bind(&g) }
-        expect(lhs).to eq(rhs)
+      context "when i have just :x" do
+        it do
+          lhs = Just(:x).public_send(m, &f).public_send(m, &g)
+          rhs = Just(:x).bind { |x| f.(x).public_send(m, &g) }
+          expect(lhs).to eq(rhs)
+        end
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ribimaybe
 version: !ruby/object:Gem::Version
-  version: 0.0.12
+  version: 0.0.13
 platform: ruby
 authors:
 - unsymbol