ribimaybe 0.0.8 → 0.0.9

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    Y2ZiYzYyM2ZhNjJmNjZmZWQ0ODEzNTE5Nzc2ODNhMzZhZTkxODVhZA==
-  data.tar.gz: !binary |-
-    YTBjMmYwM2FkNjUwNDc0MjhiN2Y4MjM4YjMzNGQ0YjQ3MmQ5OTc3Zg==
+SHA1:
+  metadata.gz: 6db212d9c3464928b07c3bb761205ed07313e566
+  data.tar.gz: ca60246d186c728d0f4da756826523f26b3ba814
 SHA512:
-  metadata.gz: !binary |-
-    NjE4MGQ5MjNjZTViZjUyMGNhNDRjNWM4MjczZTQ1YzNmMjAzYzNjNDc3NjQw
-    MzdmYjYzOThhZTZlOTY3ZDc1NDFhMzE3MDkyODJjMTc1Njc0NjhkMmJiNDM2
-    MTgzMWY3ZTVmOTVjMTE5NjM1Zjc3YzQ0ZDg3MTk2YjEwYmJkYWE=
-  data.tar.gz: !binary |-
-    ZWQzMWIzMTk1ZGVkMDQ0ZTE0OWU1ZjExNGQyZDk2OTBkZmM1YzJhNTYwZGVl
-    NjUwMDJiNTUxYzExYzhiOWY0ZWRmOTBkOGQ2ZjE0Nzg2ZDU2ZjBhNzM4ZTM0
-    ODhhYzhiMGZmNTMzZGFhNzAxMTJjNTIyZDEwNjZlMThmM2ZmNDk=
+  metadata.gz: 84aa2de634c9d305c7d27fed5a267ce2a275bd87bed2f73aed3b47e2170e609da37742bacda67af1324d0d5337311a3ae9ea40abb06bfc58a15dd5d8986dc7df
+  data.tar.gz: 6bd80d6844bd70110234b5e75686d26a7ab7a4d05f022e6181064c7f5b5f1fe2110119b4365ee8a63897710f0ee272b7047ee1bed261d71898b08000224036d8

data/lib/ribimaybe.rb

@@ -13,6 +13,8 @@ module Ribimaybe
         "Nothing"
       end
 
+      alias_method :inspect, :to_s
+
       # No operation. Always returns the default value.
       #
       Contract Any, Proc => Any
@@ -49,10 +51,14 @@ module Ribimaybe
         @value = value
       end
 
+      # Just string representation.
+      #
       def to_s
         "Just(#{@value.inspect})"
       end
 
+      alias_method :inspect, :to_s
+
       # Compares a Just to another Maybe.
       #
       # ==== Attributes

data/lib/version.rb

@@ -1,3 +1,3 @@
 module Ribimaybe
-  VERSION = "0.0.8"
+  VERSION = "0.0.9"
 end

data/spec/applicative_functor_spec.rb

@@ -1,44 +1,101 @@
 require "spec_helper"
 include Ribimaybe::Maybe
-
 describe "Applicative Instance" do
-  describe "#pure" do
-    context "when i provide a nil" do
-      it "should give me back nothing" do
-        result = pure(nil)
-        expect(result).to eq Nothing
+  let(:ap) do
+    ->(f, a){ f.(a) }.curry
+  end
+
+  let(:id) do
+    ->(x){ x }
+  end
+
+  let(:dot) do
+    ->(f, g){ ->(x){ f.(g.(x)) } }
+  end
+
+  let(:f) do
+    ->(x){ ->(y) { x } }.(SecureRandom.base64(1000))
+  end
+
+  let(:g) 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)
+      end
+    end
+
+    context "when i have just :x" do
+      it do
+        expect(pure(&id).apply(pure(:x))).to eq(pure(:x))
+      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)
       end
     end
 
-    context "when i provide a value" do
-      it "should wrap the value" do
-        result = pure(42)
-        expect(result).to eq Just(42)
+    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)
       end
     end
   end
 
-  describe "#apply" do
+  # pure f <*> pure x = pure (f x)
+  describe "homomorphism" do
     context "when i have nothing" do
-      it "should give me back nothing" do
-        result = Nothing.apply Just(42)
-        expect(result).to eq Nothing
+      it do
+        expect(pure(&f).apply(Nothing)).to eq(Nothing)
       end
     end
 
-    context "when i something containing a fn" do
-      it "should be apply to apply that fn to something" do
-        result = pure do |x|
-          x + x
-        end.apply Just(21)
-        expect(result).to eq Just(42)
+    context "when i have just :x" do
+      it do
+        expect(pure(&f).apply(pure(:x))).to eq(pure(f.(:x)))
       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))
+      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)))
+      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))
+      end
+    end
 
-      it "should be curried by default" do
-        result = pure do |x, y|
-          x + y
-        end.apply(Just(21)).apply(Just(21))
-        expect(result).to eq Just(42)
+    context "when i have just :x" do
+      it do
+        expect(Just(:x).map(&f)).to eq(pure(&f).apply(Just(:x)))
       end
     end
   end

data/spec/functor_spec.rb

@@ -1,19 +1,44 @@
 require "spec_helper"
 include Ribimaybe::Maybe
-
 describe "Functor Instance" do
-  describe "#map" do
+  let(:id) do
+    ->(x){ x }
+  end
+
+  let(:f) do
+    ->(x){ ->(y) { x } }.(SecureRandom.base64(1000)).extend(Composable)
+  end
+
+  let(:g) do
+    ->(x){ ->(y) { x } }.(SecureRandom.base64(1000)).extend(Composable)
+  end
+
+  # fmap id = id
+  describe "identity" do
+    context "when i have nothing" do
+      it do
+        expect(Nothing.map(&id)).to eq(Nothing)
+      end
+    end
+
+    context "when i have just :x" do
+      it do
+        expect(Just(:x).map(&id)).to eq(Just(:x))
+      end
+    end
+  end
+
+  # fmap (f . g) = fmap f . fmap g
+  describe "composition" do
     context "when i have nothing" do
-      it "should give me back nothing" do
-        result = Nothing.map { |x| x + 1 }
-        expect(result).to eq Nothing
+      it do
+        expect(Nothing.map(&(f * g))).to eq(Nothing.map(&g).map(&f))
       end
     end
 
-    context "when i have something" do
-      it "should apply the fn and we-wrap the value" do
-        result = Just(41).map { |x| x + 1 }
-        expect(result).to eq Just(42)
+    context "when i have just :x" do
+      it do
+        expect(Just(:x).map(&(f * g))).to eq(Just(:x).map(&g).map(&f))
       end
     end
   end

data/spec/maybe_spec.rb

@@ -1,19 +1,32 @@
 require "spec_helper"
 include Ribimaybe::Maybe
-
 describe Ribimaybe::Maybe do
   describe ".maybe" do
     context "when i have nothing" do
       it "should give me back a default" do
-        result = Nothing.maybe(42) { |x| x + 1 }
-        expect(result).to eq 42
+        expect(Nothing.maybe(false) { |_| true }).to eq(false)
       end
     end
+  end
 
+  describe "#maybe" do
     context "when i have something" do
       it "should give me back something" do
-        result = Just(42).maybe(1) { |x| x }
-        expect(result).to eq 42
+        expect(Just(:x).maybe(:y) { |x| x }).to eq(:x)
+      end
+    end
+  end
+
+  describe "#Maybe()" do
+    context "when i have nil" do
+      it "should give me back nothing" do
+        expect(Maybe(nil)).to eq(Nothing)
+      end
+    end
+
+    context "when i have :x" do
+      it "should give me back just :x" do
+        expect(Maybe(:x)).to eq(Just(:x))
       end
     end
   end

data/spec/monad_spec.rb

@@ -0,0 +1,60 @@
+require "spec_helper"
+include Ribimaybe::Maybe
+describe "Monad Instance" do
+  let(:f) do
+    ->(x){ ->(y) { rturn(x) } }.(SecureRandom.base64(1000))
+  end
+
+  let(:g) 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(&f)).to eq(Nothing)
+      end
+    end
+
+    context "when i have just :x" do
+      it do
+        expect(rturn(:x).bind(&f)).to eq(f.(:a))
+      end
+    end
+  end
+
+  # m >>= return = m
+  describe "right identity" do
+    context "when i have nothing" do
+      it do
+        expect(Nothing.bind { |x| rturn(x) }).to eq(Nothing)
+      end
+    end
+
+    context "when i have just :x" do
+      it do
+        expect(Just(:x).bind { |x| rturn(x) }).to eq(Just(:x))
+      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)
+      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)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -7,3 +7,13 @@ require "rubygems"
 
 RSpec.configure do |config|
 end
+
+module Composable
+  def compose(f, g)
+    ->(x){f.(g.(x))}
+  end
+
+  def *(g)
+    compose(self, g)
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ribimaybe
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.0.9
 platform: ruby
 authors:
 - unsymbol
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-08 00:00:00.000000000 Z
+date: 2014-06-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -28,42 +28,42 @@ dependencies:
   name: pry
   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'
 - !ruby/object:Gem::Dependency
   name: rake
   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'
 - !ruby/object:Gem::Dependency
   name: rspec
   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'
 - !ruby/object:Gem::Dependency
@@ -100,7 +100,7 @@ files:
 - spec/applicative_functor_spec.rb
 - spec/functor_spec.rb
 - spec/maybe_spec.rb
-- spec/monad_instance_spec.rb
+- spec/monad_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/unsymbol/ribimaybe
 licenses:
@@ -112,17 +112,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.1.11
+rubygems_version: 2.0.2
 signing_key: 
 specification_version: 4
 summary: A tiny Ruby library that provides a Maybe datatype which is a Functor, Applicative
@@ -131,5 +131,5 @@ test_files:
 - spec/applicative_functor_spec.rb
 - spec/functor_spec.rb
 - spec/maybe_spec.rb
-- spec/monad_instance_spec.rb
+- spec/monad_spec.rb
 - spec/spec_helper.rb

data/spec/monad_instance_spec.rb

@@ -1,40 +0,0 @@
-require "spec_helper"
-include Ribimaybe::Maybe
-
-describe "Monad Instance" do
-  describe "#rturn" do
-    context "when i provide a nil" do
-      it "should give me back nothing" do
-        result = rturn(nil)
-        expect(result).to eq Nothing
-      end
-    end
-
-    context "when i provide a value" do
-      it "should wrap the value" do
-        result = rturn(42)
-        expect(result).to eq Just(42)
-      end
-    end
-  end
-
-  describe "#bind" do
-    context "when i have nothing" do
-      it "should give me back nothing" do
-        result = Nothing.bind do |x|
-          rturn x + x
-        end
-        expect(result).to eq Nothing
-      end
-    end
-
-    context "when i something containing a fn" do
-      it "should be apply to apply that fn to something" do
-        result = Just(21).bind do |x|
-          rturn x + x
-        end
-        expect(result).to eq Just(42)
-      end
-    end
-  end
-end