mon 0.0.2

data/spec/monad_spec.rb

@@ -0,0 +1,757 @@
+require_relative '../lib/mon'
+
+module Mon
+
+  module Monad
+
+    describe "List" do
+      
+      describe "[]" do
+        it "takes a sequence and turns it into a list monad" do
+          List[1, 2, 3].to_a.should eql [1, 2, 3]
+          List[].to_a.should eql []
+        end
+
+        it "should preserve arrays" do
+          List[[1, 2, 3]].to_a.should eql [[1, 2, 3]]
+        end
+        
+        it "should preserve lists" do
+          List[List[1, 2, 3]].to_a.should eql [List[1, 2, 3]]
+        end
+      end
+
+      describe "==" do
+        it "should compare two List monads" do
+          List[1, 2, 3].should == List[1, 2, 3]
+          List["one", "two"].should == List["one", "two"]
+        end
+
+        it "should compare contents if not given a List monad" do
+          List[1, 2, 3].should == [1, 2, 3]
+          List["one", "two"].should == ["one", "two"]
+        end
+
+        it "shouldn't match non-matching List monads" do
+          List[1, 2, 3].should_not == List[3, 2, 1]
+          List["one", "two"].should_not == List["one"]
+        end
+
+        it "shouldn't match contents if not given a List monad" do
+          List[1, 2, 3].should_not == [3, 2, 1]
+          List["one", "two"].should_not == ["two", "one"]
+        end
+      end
+      
+      describe "eql" do
+        it "should compare two List monads" do
+          List[1, 2, 3].should eql List[1, 2, 3]
+          List["one", "two"].should eql List["one", "two"]
+        end
+
+        it "should compare contents if not given a List monad" do
+          List[1, 2, 3].should eql [1, 2, 3]
+          List["one", "two"].should eql ["one", "two"]
+        end
+
+        it "shouldn't match non-matching List monads" do
+          List[1, 2, 3].should_not eql List[3, 2, 1]
+          List["one", "two"].should_not eql List["one"]
+        end
+
+        it "shouldn't match contents if not given a List monad" do
+          List[1, 2, 3].should_not eql [3, 2, 1]
+          List["one", "two"].should_not eql ["two", "one"]
+        end
+      end
+      
+      describe "new" do
+        it "should be protected" do
+          expect { List.new([1, 2, 3]) }.to raise_error(NoMethodError)
+        end
+      end
+      
+      describe "get" do
+        it "should be protected" do
+          expect { List[1, 2, 3].get }.to raise_error(NoMethodError)
+        end
+      end
+      
+      describe "_canBind?" do
+        it "should be protected" do
+          expect { List[1]._canBind? :test }.to raise_error(NoMethodError)
+        end
+      end
+      
+      describe "to_s" do
+        it "should properly handle 0, 1, 3, 4+ items" do
+          List[].to_s.should eql "List[]"
+          List[1].to_s.should eql "List[1]"
+          List[1, 2, 3].to_s.should eql "List[1, 2, 3]"
+          List[1, 2, 3, 4].to_s.should eql "List[1, 2, 3...]"
+        end
+      end
+      
+      describe "list functionality" do
+        it "should pass methods through to the contained object" do
+          (List[1, 2, 3] * 6).to_a.should eql [6, 12, 18]
+          (List["Test", "One", "Two"].downcase).to_a.should eql ["test", "one", "two"]
+        end
+        
+        it "should treat missing_methods the same as bind" do
+          (List[1, 2, 3] * 5).to_a.should eql (List[1, 2, 3].bind { |i| i * 5 }.to_a)
+        end
+        
+        it "should flatten once" do
+          List[1, 2, 3].bind { |i| [i, i * 2] }.to_a.should eql [1, 2, 2, 4, 3, 6]
+        end
+        
+        it "should allow for internal transformation" do
+          List[1].bind { |i| Try[i] }.to_a.should eql [Success[1]]
+        end
+        
+        it "should allow chaining methods" do
+          (((List[1, 2, 3] + 2) * 3) - 5).to_a.should eql [4, 7, 10]
+          List[1, 6, 9].to_f.div(2).floor.round.should eql [0, 3, 4]
+        end
+
+        it "should work with empty lists" do
+          (List[] * 3 + 5 - 2).should eql List[]
+          (List[].upcase.downcase.reverse).should eql List[]
+        end
+      end
+      
+      describe "monad laws" do
+        it "should obey left identity (but it won't)" do
+          (List[1] * 3).should eql [(1 * 3)]
+        end
+        
+        it "should obey right identity" do
+          List[1, 2].bind { |i| i }.should eql List[1, 2]
+          List[1, 2].bind { |i| List[i] }.should eql List[1, 2]
+        end
+        
+        it "should obey associativity" do
+          ((List[3] * 5) * 9).should eql (List[3] * (5 * 9))
+          ((3 * List[5]) * 9).should eql (3 * (List[5] * 9))
+          (List[3] * 5).should eql (3 * List[5])
+          ((3 * List[]) * 9).should eql (3 * (List[] * 9))
+          ((List[] * 5) * 9).should eql (List[] * (5 * 9))
+        end
+      end
+    end
+
+    describe Maybe do
+      describe "[]" do
+        it "should take an arbitrary object" do
+          Maybe[1].or(0).should == 1
+          Maybe["test"].or("").should == "test"
+          Maybe[[1, 2, 3]].or([]).should == [1, 2, 3]
+          Maybe[List[1, 2]].or(List[]).should == List[1, 2]
+        end
+
+        it "should unwrap to one level" do
+          Maybe[Maybe[1]].or(Maybe[false]).should == 1
+          Maybe[Maybe[Maybe[1]]].or(false).should == Maybe[1]
+        end
+
+        it "should return Some/None appropriately" do
+          Maybe[true].should == Some[true]
+          Maybe[false].should == None[]
+          Maybe[nil].should == None[]
+          Maybe[1].should == Some[1]
+          Maybe["test"].should == Some["test"]
+        end
+      end
+
+      describe "==" do
+        it "should compare internals" do
+          Maybe[1].should == Maybe[1]
+          Maybe["test"].should == Maybe["test"]
+          Maybe[[1, 2, 3]].should == Maybe[[1, 2, 3]]
+        end
+
+        it "should not match when objects don't" do
+          Maybe[1].should_not == Maybe[2]
+          Maybe["test"].should_not == Maybe["other"]
+          Maybe[[1, 2, 3]].should_not == Maybe[[3, 2, 1]]
+        end
+
+        it "should compare provided non-options to internals" do
+          Maybe[1].should == 1
+          Maybe["test"].should == "test"
+          Maybe[[1, 2, 3]].should == [1, 2, 3]
+          Maybe[1].should_not == 2
+          Maybe["test"].should_not == "other"
+          Maybe[[1, 2, 3]].should_not == [3, 2, 1]
+        end
+      end
+
+      describe "eql" do
+        it "should compare internals" do
+          Maybe[1].should eql Maybe[1]
+          Maybe["test"].should eql Maybe["test"]
+          Maybe[[1, 2, 3]].should eql Maybe[[1, 2, 3]]
+        end
+
+        it "should not match when objects don't" do
+          Maybe[1].should_not eql Maybe[2]
+          Maybe["test"].should_not eql Maybe["other"]
+          Maybe[[1, 2, 3]].should_not eql Maybe[[3, 2, 1]]
+        end
+
+      it "should compare provided non-options to internals" do
+        Maybe[1].should eql 1
+        Maybe["test"].should eql "test"
+        Maybe[[1, 2, 3]].should eql [1, 2, 3]
+        Maybe[1].should_not eql 2
+        Maybe["test"].should_not eql "other"
+        Maybe[[1, 2, 3]].should_not eql [3, 2, 1]
+      end
+    end
+
+    describe "bind" do
+      it "should apply function to the internals" do
+        Maybe[1].bind { |i| i * 3 }.should == Maybe[3]
+        Maybe["test"].bind { |s| s.upcase }.should == Maybe["TEST"]
+      end
+
+      it "should modify contents of monad" do
+        Maybe[1].bind { |i| List[1] }.or(false).should == List[1]
+        Maybe["test"].bind { |i| [i] }.or([]).should == ["test"]
+      end
+    end
+
+    describe "maybe functionality" do
+      it "should pass methods through to the contained object" do
+        (Maybe[1] * 3).should == Maybe[3]
+        (Maybe["test"].upcase).should == Maybe["TEST"]
+        ((Maybe[5] * 10) - 12).should == Maybe[38]
+        Maybe["test"].upcase.reverse.downcase.should == Maybe["tset"]
+      end
+      
+      it "should treat missing_methods the same as bind" do
+        (Maybe[5] * 5).should == Maybe[5].bind { |i| i * 5 }
+      end
+      
+      it "should flatten once" do
+        Maybe[5].bind { |i| Some[i * 100] }.should == Maybe[500]
+      end
+
+      it "should allow for chained and multibound failures" do
+        (Maybe[nil] * 5 + 2 - 3).should == None[]
+      end
+    end
+    
+    describe "monad laws" do
+      it "should obey left identity (but it won't)" do
+        (Maybe[1] * 3).should == (1 * 3)
+      end
+      
+      it "should obey right identity" do
+        Maybe[1].bind { |i| i }.should == Maybe[1]
+        Maybe[5].bind { |i| Maybe[i] }.should == Maybe[5]
+      end
+
+      it "should obey associativity" do
+        ((Maybe[5] * Maybe[3]) * Maybe[5]).should == (Maybe[5] * (Maybe[3] * Maybe[5]))
+        ((Maybe[5] * Maybe[3]) * None[]).should == (Maybe[5] * (Maybe[3] * None[]))
+        ((Maybe[5] * 3) * Maybe[5]).should == (5 * (Maybe[3] * Maybe[5]))
+      end
+    end
+  end
+
+  describe "Try" do
+    describe "[]" do
+      it "should take an arbitrary object" do
+        Try[1].or(0).should == 1
+        Try["test"].or("").should == "test"
+        Try[[1, 2, 3]].or([]).should == [1, 2, 3]
+        Try[List[1, 2]].or(List[]).should == List[1, 2]
+      end
+
+      it "should NOT unwrap" do
+        Try[Try[1]].or(Try[false]).should == Try[1].bind { |i| Try[i] }
+      end
+
+      it "should return Success/Failure appropriately" do
+        Try[true].should == Success[true]
+        Try[false].should == Failure[false]
+        Try[nil].should == Failure[false]
+        Try[1].should == Success[1]
+        Try["test"].should == Try["test"]
+      end
+    end
+
+    describe "==" do
+      it "should compare internals" do
+        Try[1].should == Try[1]
+        Try["test"].should == Try["test"]
+        Try[[1, 2, 3]].should == Try[[1, 2, 3]]
+      end
+
+      it "should not match when objects don't" do
+        Try[1].should_not == Try[2]
+        Try["test"].should_not == Try["other"]
+        Try[[1, 2, 3]].should_not == Try[[3, 2, 1]]
+      end
+
+      it "should compare provided non-options to internals" do
+        Try[1].should == 1
+        Try["test"].should == "test"
+        Try[[1, 2, 3]].should == [1, 2, 3]
+        Try[1].should_not == 2
+        Try["test"].should_not == "other"
+        Try[[1, 2, 3]].should_not == [3, 2, 1]
+      end
+    end
+
+    describe "eql" do
+      it "should compare internals" do
+        Try[1].should eql Try[1]
+        Try["test"].should eql Try["test"]
+        Try[[1, 2, 3]].should eql Try[[1, 2, 3]]
+      end
+
+      it "should not match when objects don't" do
+        Try[1].should_not eql Try[2]
+        Try["test"].should_not eql Try["other"]
+        Try[[1, 2, 3]].should_not eql Try[[3, 2, 1]]
+      end
+
+      it "should compare provided non-options to internals" do
+        Try[1].should eql 1
+        Try["test"].should eql "test"
+        Try[[1, 2, 3]].should eql [1, 2, 3]
+        Try[1].should_not eql 2
+        Try["test"].should_not eql "other"
+        Try[[1, 2, 3]].should_not eql [3, 2, 1]
+      end
+    end
+
+    describe "bind" do
+      it "should apply function to the internals" do
+        Try[1].bind { |i| i * 3 }.should == Try[3]
+        Try["test"].bind { |s| s.upcase }.should == Try["TEST"]
+      end
+
+      it "should modify contents of monad" do
+        Try[1].bind { |i| List[1] }.or(false).should == List[1]
+        Try["test"].bind { |i| [i] }.or([]).should == ["test"]
+      end
+
+      it "should catch exceptions" do
+        expect(Try[1].bind { |i| i / 0 }).to be_a Failure
+        expect(Try[1].bind { |i| i * 5 }).to be_a Success
+      end
+
+      it "should allow chains even for failures" do
+        expect(Try[1].bind { |i| i / 0 } * 7 + 3).to be_a Failure
+        expect(Try[5].bind { |i| i * 5 } + 6 - 3).to be_a Success
+        expect(Try[10].bind { |i| i / 0 }.bind { |i| i + 3}).to be_a Failure
+        expect(Try[10].bind { |i| i + 0 }.bind { |i| i + 3}).to be_a Success
+      end
+
+      it "should preserve exceptions" do
+        expect{(Try[5].bind { |i| i / 0 } * 7 + 3).orFail}.to raise_error(ZeroDivisionError)
+        (Try[5].bind { |i| i / 1 } * 7 + 3).orFail.should == 38
+      end
+    end
+
+    describe "try functionality" do
+      it "should pass methods through to the contained object" do
+        (Try[1] * 3).should == Try[3]
+        (Try["test"].upcase).should == Try["TEST"]
+        ((Try[5] * 10) - 12).should == Try[38]
+        Try["test"].upcase.reverse.downcase.should == Try["tset"]
+      end
+      
+      it "should treat missing_methods the same as bind" do
+        (Try[5] * 5).should == Try[5].bind { |i| i * 5 }
+      end
+      
+      it "should flatten once" do
+        Try[5].bind { |i| Some[i * 100] }.should == Try[500]
+      end
+
+      it "should allow for chained and multibound failures" do
+        (Try[nil] * 5 + 2 - 3).should == Failure[false]
+      end
+
+      it "should catch exceptions" do
+        expect(Try.to(5) { |i| i / 0 }).to be_a Failure
+        expect(Try.to(5) { |i| i / 5 }).to be_a Success
+        Try.to(5) { |i| i * 5 }.should == Success[25]
+      end
+    end
+    
+    describe "monad laws" do
+      it "should obey left identity (but it won't)" do
+        (Try[1] * 3).should == (1 * 3)
+      end
+      
+      it "should obey right identity" do
+        Try[1].bind { |i| i }.should == Try[1]
+        Try[5].bind { |i| Try[i] }.should == Try[5]
+      end
+
+      it "should obey associativity" do
+        ((Try[5] * Try[3]) * Try[5]).should == (Try[5] * (Try[3] * Try[5]))
+        ((Try[5] * Try[3]) * Failure["Nope!"]).should == (Try[5] * (Try[3] * Failure["Nope!"]))
+        ((5 * Try[3]) * Try[5]).should == (Try[5] * (3 * Try[5]))
+        ((5 * 3) * Try[5]).should == (5 * (3 * Try[5]))
+      end
+    end
+  end
+
+  describe "Lazy" do
+    describe "[]" do
+      it "should wrap an object" do
+        Lazy.eventually(1) { |i| 1 }.should == 1
+        Lazy.eventually([1, 2, 3]) { |l| l } == [1, 2, 3]
+      end
+
+      it "should return Pending/Final appropriately" do
+        expect(Lazy[1]).to be_a Final
+        expect(Lazy["testing"]).to be_a Final
+        expect(Lazy.eventually { "testing" }).to be_a Pending
+        expect(Lazy.eventually { [1, 2] }).to be_a Pending
+      end
+    end
+
+    describe "==" do
+      it "should compare internals" do
+        Lazy[1].should == Lazy[1]
+        Lazy[[1, 2, 3]].should == Lazy[[1, 2, 3]]
+      end
+
+      it "should compare pending with final" do
+        Lazy.eventually { 1 }.should == Lazy[1]
+        Lazy.eventually { [1, 2, 3] }.should == Lazy[[1, 2, 3]]
+      end
+
+      it "should not match when objects don't" do
+        Lazy[1].should_not == Lazy[2]
+        Lazy.eventually { 1 }.should_not == Lazy.eventually { 2 }
+        Lazy.eventually { 2 }.should_not == Lazy[1]
+      end
+
+      it "should compare provided non-Lazy to internals" do
+        Lazy[1].should == 1
+        Lazy["test"].should == "test"
+        Lazy[[1, 2, 3]].should == [1, 2, 3]
+        Lazy[].should_not == 1
+        Lazy[1].should_not == 2
+        Lazy.eventually { 1 }.should == 1
+        Lazy.eventually { "test" }.should == "test"
+        Lazy.eventually { [1, 2, 3] }.should == [1, 2, 3]
+        Lazy.eventually { }.should_not == 1
+        Lazy.eventually { 1 }.should_not == 2
+      end
+    end
+
+    describe "bind" do
+      it "should create a pending calculation" do
+        expect(Lazy[5].bind { |i| i * 5 }).to be_a Pending
+        expect(Lazy[10].bind { |i| i * 5 }.bind { |i| i * 7 }).to be_a Pending
+      end
+
+      it "should finalize correctly" do
+        Lazy[5].bind { |i| i * 5 }.should == Lazy[25]
+        Lazy[1].bind { |i| i * 7 }.bind { |i| i * 2 }.should == Lazy[14]
+        Lazy["test"].bind { |s| s.upcase }.bind { |s| s.reverse }.should == Lazy["TSET"]
+      end
+
+      it "should be able to modify monad contents" do
+        Lazy[5].bind { |i| Try[i] }.should == Lazy[Try[5]]
+        Lazy["test"].bind { |i| [i] }.should == Lazy[["test"]]
+      end
+
+      it "should flatten by one level" do
+        Lazy[5].bind { |i| Lazy[i] }.should == Lazy[5]
+        Lazy.eventually { [1, 2, 3] }.bind { |i| Lazy[i] }.should == Lazy[[1, 2, 3]]
+      end
+
+    end
+    
+    describe "functionality" do
+      it "should pass methods through to the contained object" do
+        (Lazy[1] * 3).should == Lazy[3]
+        (Lazy["test"].upcase.reverse).should == Lazy["TSET"]
+        (Lazy["this is a test"][0,4]).should == Lazy["this"]
+      end
+
+      it "shouldn't execute until necessary" do
+        expect(Lazy[1] * 3).to be_a Pending
+        expect(Lazy["test"].upcase.reverse).to be_a Pending
+        expect(Lazy["this is a test"][0,4]).to be_a Pending
+      end
+
+      it "should treat missing_methods the same as bind" do
+        (Lazy[5] * 5).should == Lazy[5].bind { |i| i * 5 }
+      end
+    end
+    
+    describe "monad laws" do
+      it "should obey left identity (but it won't)" do
+        (Lazy[1] * 3).should == (1 * 3)
+      end
+      
+      it "should obey right identity" do
+        Lazy[1].bind { |i| i }.should == Lazy[1]
+        Lazy[5].bind { |i| Lazy[i] }.should == Lazy[5]
+      end
+
+      it "should obey associativity" do
+        ((Lazy[5] * Lazy[3]) * Lazy[5]).should == (Lazy[5] * (Lazy[3] * Lazy[5]))
+        ((Lazy[3] * 5) * 9).should eql (Lazy[3] * (5 * 9))
+        ((3 * Lazy[5]) * 9).should eql (3 * (Lazy[5] * 9))
+        (Lazy[3] * 5).should eql (3 * Lazy[5])
+        ((3 * Lazy[7]) * 9).should eql (3 * (Lazy[7] * 9))
+        ((Lazy[7] * 5) * 9).should eql (Lazy[7] * (5 * 9))
+      end
+    end
+  end
+  
+  describe "Future" do
+    describe "[]" do
+      it "should wrap an object" do
+        Future[1].should == 1
+        Future.eventually(1) { |i| 1 }.should == 1
+        Future[[1, 2, 3]].should == [1, 2, 3]
+        Future.eventually([1, 2, 3]) { |l| l } == [1, 2, 3]
+      end
+
+      it "should return Complete/Promise appropriately" do
+        expect(Future[1]).to be_a FutureComplete
+        expect(Future["testing"]).to be_a FutureComplete
+        expect(Future.eventually { "testing" }).to be_a FuturePromise
+        expect(Future.eventually { [1, 2] }).to be_a FuturePromise
+      end
+    end
+
+    describe "==" do
+      it "should compare internals" do
+        Future[1].should == Future[1]
+        Future[[1, 2, 3]].should == Future[[1, 2, 3]]
+      end
+
+      it "should compare pending with final" do
+        Future.eventually { 1 }.should == Future[1]
+        Future.eventually { [1, 2, 3] }.should == Future[[1, 2, 3]]
+      end
+
+      it "should not match when objects don't" do
+        Future[1].should_not == Future[2]
+        Future.eventually { 1 }.should_not == Future.eventually { 2 }
+        Future.eventually { 2 }.should_not == Future[1]
+      end
+
+      it "should compare provided non-Future to internals" do
+        Future[1].should == 1
+        Future["test"].should == "test"
+        Future[[1, 2, 3]].should == [1, 2, 3]
+        Future[1].should_not == 2
+        Future.eventually { 1 }.should == 1
+        Future.eventually { "test" }.should == "test"
+        Future.eventually { [1, 2, 3] }.should == [1, 2, 3]
+        Future.eventually { }.should_not == 1
+        Future.eventually { 1 }.should_not == 2
+      end
+    end
+
+    describe "bind" do
+      it "should create a pending calculation" do
+        expect(Future[5].bind { |i| i * 5 }).to be_a FuturePromise
+        expect(Future[10].bind { |i| i * 5 }.bind { |i| i * 7 }).to be_a FuturePromise
+      end
+
+      it "should finalize correctly" do
+        Future[5].bind { |i| i * 5 }.should == Future[25]
+        Future[1].bind { |i| i * 7 }.bind { |i| i * 2 }.should == Future[14]
+        Future["test"].bind { |s| s.upcase }.bind { |s| s.reverse }.should == Future["TSET"]
+      end
+
+      it "should be able to modify monad contents" do
+        Future[5].bind { |i| Try[i] }.should == Future[Try[5]]
+        Future["test"].bind { |i| [i] }.should == Future[["test"]]
+      end
+
+      it "should flatten by one level" do
+        Future[5].bind { |i| Future[i] }.should == Future[5]
+        Future.eventually { [1, 2, 3] }.bind { |i| Future[i] }.should == Future[[1, 2, 3]]
+      end
+
+    end
+    
+    describe "functionality" do
+      it "should pass methods through to the contained object" do
+        (Future[1] * 3).should == Future[3]
+        (Future["test"].upcase.reverse).should == Future["TSET"]
+        (Future["this is a test"][0,4]).should == Future["this"]
+      end
+
+      it "should treat missing_methods the same as bind" do
+        (Future[5] * 5).should == Future[5].bind { |i| i * 5 }
+      end
+    end
+    
+    describe "monad laws" do
+      it "should obey left identity (but it won't)" do
+        (Future[1] * 3).should == (1 * 3)
+      end
+      
+      it "should obey right identity" do
+        Future[1].bind { |i| i }.should == Future[1]
+        Future[5].bind { |i| Future[i] }.should == Future[5]
+      end
+
+      it "should obey associativity" do
+        ((Future[5] * Future[3]) * Future[5]).should == (Future[5] * (Future[3] * Future[5]))
+        ((Future[3] * 5) * 9).should eql (Future[3] * (5 * 9))
+        ((3 * Future[5]) * 9).should eql (3 * (Future[5] * 9))
+        (Future[3] * 5).should eql (3 * Future[5])
+        ((3 * Future[7]) * 9).should eql (3 * (Future[7] * 9))
+        ((Future[7] * 5) * 9).should eql (Future[7] * (5 * 9))
+      end
+    end
+  end
+
+  describe "Reactron" do
+    describe "[]" do
+      it "should wrap an object" do
+        React[1].should == 1
+        React[[1, 2, 3]].should == [1, 2, 3]
+      end
+
+      it "should return Pending/Final appropriately" do
+        expect(React[1]).to be_a Reactron
+        expect(React["testing"]).to be_a Reactron
+        expect(React[5] * 2).to be_a Reactor
+        expect(React["test"].upcase).to be_a Reactor
+      end
+    end
+
+    describe "==" do
+      it "should compare internals" do
+        React[1].should == React[1]
+        React[[1, 2, 3]].should == React[[1, 2, 3]]
+      end
+
+      it "should compare reactor with reactron" do
+        (React[5] * 10).should == React[50]
+      end
+
+      it "should not match when objects don't" do
+        React[1].should_not == React[2]
+        (React[2] * 4).should_not == React[9]
+      end
+
+      it "should compare provided non-React to internals" do
+        React[1].should == 1
+        React["test"].should == "test"
+        (React[1] * 5).should == 5
+        React["test"].upcase.should == "TEST"
+        React[[1, 2, 3]].should == [1, 2, 3]
+        React[1].should_not == 2
+        React[[1, 2, 3]].map { |i| i * 7 }.should == [7, 14, 21]
+        React["test"].reverse.should_not == "test"
+      end
+    end
+
+    describe "bind" do
+      it "should create a pending calculation" do
+        expect(React[5].bind { |i| i * 5 }).to be_a Reactor
+        expect(React[10].bind { |i| i * 5 }.bind { |i| i * 7 }).to be_a Reactor
+      end
+
+      it "should finalize correctly" do
+        React[5].bind { |i| i * 5 }.should == React[25]
+        React[1].bind { |i| i * 7 }.bind { |i| i * 2 }.should == React[14]
+        React["test"].bind { |s| s.upcase }.bind { |s| s.reverse }.should == React["TSET"]
+      end
+
+      it "should be able to modify monad contents" do
+        React[5].bind { |i| Try[i] }.should == React[Try[5]]
+        React["test"].bind { |i| [i] }.should == React[["test"]]
+      end
+
+      it "should flatten by one level" do
+        React[5].bind { |i| React[i] }.should == React[5]
+        React[[1, 2, 3]].bind { |i| React[i] }.should == React[[1, 2, 3]]
+      end
+
+    end
+    
+    describe "functionality" do
+      it "should pass methods through to the contained object" do
+        (React[1] * 3).should == React[3]
+        (React["test"].upcase.reverse).should == React["TSET"]
+        (React["this is a test"][0,4]).should == React["this"]
+      end
+
+      it "shouldn't execute until necessary" do
+        expect(React[1] * 3).to be_a Reactor
+        expect(React["test"].upcase.reverse).to be_a Reactor
+        expect(React["this is a test"][0,4]).to be_a Reactor
+      end
+
+      it "should treat missing_methods the same as bind" do
+        (React[5] * 5).should == React[5].bind { |i| i * 5 }
+      end
+
+      it "should chain reactions together" do
+        x = React[5]
+        y = x * 10
+        z = y * 10
+        a = x * 5
+        expect(x.should == 5)
+        expect(y.should == 50)
+        expect(z.should == 500)
+        expect(a.should == 25) 
+        x << 10
+        expect(x.should == 10)
+        expect(y.should == 100)
+        expect(z.should == 1000)
+        expect(a.should == 50) 
+      end
+
+      it "should successfully combine reactrons" do
+        x = React[5]
+        y = React[7]
+        z = x * y
+        expect(z.should == 35)
+        x << 2
+        expect(z.should == 14)
+        y << 3
+        expect(z.should == 6)
+      end
+    end
+    
+    describe "monad laws" do
+      it "should obey left identity (but it won't)" do
+        (React[1] * 3).should == (1 * 3)
+      end
+      
+      it "should obey right identity" do
+        React[1].bind { |i| i }.should == React[1]
+        React[5].bind { |i| React[i] }.should == React[5]
+      end
+
+      it "should obey associativity" do
+        ((React[5] * React[3]) * React[5]).should == (React[5] * (React[3] * React[5]))
+        ((React[3] * 5) * 9).should eql (React[3] * (5 * 9))
+        ((3 * React[5]) * 9).should eql (3 * (React[5] * 9))
+        (React[3] * 5).should eql (3 * React[5])
+        ((3 * React[7]) * 9).should eql (3 * (React[7] * 9))
+        ((React[7] * 5) * 9).should eql (React[7] * (5 * 9))
+      end
+    end
+  end
+
+  describe "State" do
+    
+  end
+
+end
+end