mon 0.0.2

data/lib/monads/try.rb

@@ -0,0 +1,190 @@
+
+module Mon
+
+  module Monad
+
+    require_relative 'chainable_monad'
+    require_relative 'monad'
+
+    class Try < Monad
+      include ChainableMonad
+
+      def self.[](obj)
+        if obj.is_a? Failure
+          Failure[obj.get]
+        elsif obj
+          Success[obj]
+        else
+          Failure[false]
+        end
+      end
+
+      def self::to *obj, &f
+        begin
+          if obj.length == 1 and obj[0].is_a? Proc
+            raise RuntimeError("Provided too many procs!") if f
+            Success[obj.call]
+          elsif f and obj.length > 0
+            Success[f.call(*obj)]
+          else
+            raise RuntimeError("Failed to provide block") if not f
+            Success[f.call]
+          end
+        rescue StandardError => e
+          Failure[e]
+        end
+      end
+
+      def self::valid?(o)
+        o.is_a? self.class
+      end
+
+      class << self
+        protected :new
+      end
+    end
+
+    class Success < Try
+
+      def initialize(obj)
+        if obj.is_a? Success
+          @obj = obj.get
+        else
+          @obj = obj
+        end
+        super()
+      end
+      
+      def self.[](obj)
+        if (obj.is_a? Failure) or (obj.is_a? Success)
+          obj
+        else
+          Success.new(obj)
+        end
+      end
+
+      def bind &fun
+        begin
+          Success[fun.call(@obj)]
+        rescue StandardError => e
+          Failure[e]
+        end
+      end
+
+      def _canBind?(name)
+        @obj.respond_to? name
+      end
+
+      def or obj, &f
+        @obj
+      end
+
+      def orFail
+        @obj
+      end
+
+      def unwrap
+        @obj
+      end
+      
+      def eql?(other)
+        if other.is_a? Success
+          @obj == other.unwrap
+        else
+          @obj == other
+        end
+      end
+
+      def ==(o)
+        eql?(o)
+      end
+      
+      def equal?(o)
+        eql?(o)
+      end
+
+      def to_s
+        "Success[#{@obj}]"
+      end
+
+      def self::valid?(o)
+        o.is_a? self.class
+      end
+
+      class << self
+        protected :new
+      end
+      
+      protected :unwrap, :_canBind?
+    end
+
+    class Failure < Try
+
+      def initialize(err)
+        @err = err
+      end
+
+      def self.[](err)
+        self.new(err)
+      end
+
+      def bind &fun
+        self
+      end
+
+      def or obj, &f
+        if f and obj
+          f.call(obj)
+        elsif f
+          f.call
+        else
+          obj
+        end
+      end
+
+      def orFail &f
+        if f
+          f.call(@err)
+        elsif @err.is_a? Exception
+          raise @err
+        else
+          @err
+        end
+      end
+
+      def unwrap
+        @err
+      end
+
+      def _canBind? name
+        true
+      end
+
+      def to_s
+        "Failure[#{@err}]"
+      end
+      
+      def eql?(other)
+        (other.is_a? Failure) ? (@err == other.unwrap) : false
+      end
+
+      def ==(o)
+        eql?(o)
+      end
+      
+      def equal?(o)
+        eql?(o)
+      end
+
+      def self::valid?(o)
+        o.is_a? self.class
+      end
+      
+      class << self
+        protected :new
+      end
+      
+      protected :unwrap, :_canBind?
+    end
+  end
+end

data/spec/contract_spec.rb

@@ -0,0 +1,310 @@
+ 
+require 'contracts'
+require_relative '../lib/mon'
+
+include Contracts
+
+Contract Mon::C::List[Num] => Mon::C::List[Num]
+def listSquare(i)
+  i.bind { |i| i * i }
+end
+      
+Contract Mon::C::Maybe[Num] => Mon::C::Maybe[Num]
+def maybeSquare(i)
+  i.bind { |i| i * i }
+end
+
+Contract Mon::C::Try[Num] => Mon::C::Try[Num]
+def trySquare(i)
+  i.bind { |i| i * i }
+end
+
+Contract Mon::C::Lazy[Num] => Mon::C::Lazy[Num]
+def lazySquare(i)
+  i.bind { |i| i * i }
+end
+
+Contract Mon::C::Future[Num] => Mon::C::Future[Num]
+def futureSquare(i)
+  i.bind { |i| i * i }
+end
+
+Contract Mon::C::React[Num] => Mon::C::React[Num]
+def reactSquare(i)
+  i.bind { |i| i * i }
+end
+
+Contract Mon::C::Monad[Num] => Mon::C::Monad[Num]
+def monadSquare(i)
+  i.bind { |i| i * i }
+end
+
+Contract Mon::C::Try[Mon::C::Maybe[Num]] => Mon::C::Try[Mon::C::Maybe[Num]]
+def tryMaybeSquare(i)
+  i.bind { |j| j.bind { |k| k * k } }
+end
+
+Contract Mon::C::Try[Or[Num, String]] => Mon::C::Maybe[String]
+def tryStringify(i)
+  Mon::M::Maybe[i.bind { |j| "We got: #{ j.to_s }" }._]
+end
+
+module Mon
+
+  module Contract
+    
+    describe "List" do
+      
+      it "should accept Lists" do
+        listSquare(Mon::M::List[1, 2, 3]).should eql Mon::M::List[1, 4, 9]
+      end
+
+      it "should accept empty Lists" do
+        listSquare(Mon::M::List[]).should eql Mon::M::List[]
+      end
+
+      it "should be internal-type aware" do
+        expect {
+          listSquare(Mon::M::List["test"])
+        }.to raise_error(ContractError)
+      end
+
+      it "shouldn't accept any other types" do
+        expect {
+          listSquare([5])
+        }.to raise_error(ContractError)
+      end
+      
+    end
+
+    describe "Maybe" do
+
+      it "should accept Maybe monads" do
+        maybeSquare(Mon::M::Maybe[5]).should eql Mon::M::Maybe[25]
+      end
+
+      it "should accept empty Maybe monads" do
+        maybeSquare(Mon::M::None[]).should eql Mon::M::None[]
+      end
+
+      it "shouldn't accept Maybe monads containing incorrect types" do
+        expect {
+          maybeSquare(Mon::M::Maybe["test"])
+        }.to raise_error(ContractError)
+      end
+
+      it "shouldn't accept any other types" do
+        expect {
+          maybeSquare(5)
+        }.to raise_error(ContractError)
+      end
+
+    end
+
+    describe "Try" do
+
+      it "should accept Try monads" do
+        trySquare(Mon::M::Try[5]).should eql Mon::M::Success[25]
+      end
+
+      it "should accept Failures as well as Successes" do
+        trySquare(Mon::M::Try.to { raise RuntimeError.new }).should be_a Mon::M::Failure
+      end
+
+      it "shouldn't accept Successes of the incorrect type" do
+        expect {
+          trySquare(Mon::M::Try["test"])
+        }.to raise_error(ContractError)
+      end
+
+      it "shouldn't accept non-Try types" do
+        expect {
+          trySquare(5)
+        }.to raise_error(ContractError)
+      end
+      
+      it "shouldn't accept non-Try monadic types" do
+        expect {
+          trySquare(Mon::M::Maybe[5])
+        }.to raise_error(ContractError)
+      end
+    end
+
+    describe "Lazy" do
+
+      it "should accept Lazy monads" do
+        lazySquare(Mon::M::Lazy[5]).should be_a Mon::M::Pending
+      end
+
+      it "should accept Pending as well as Final" do
+        lazySquare(Mon::M::Lazy.eventually { sleep 1; 5 }).should be_a Mon::M::Lazy
+      end
+
+      it "shouldn't accept Finals of the incorrect type" do
+        expect {
+          lazySquare(Mon::M::Try["test"])
+        }.to raise_error(ContractError)
+      end
+
+      it "shouldn't accept non-Lazy types" do
+        expect {
+          lazySquare(5)
+        }.to raise_error(ContractError)
+      end
+      
+      it "shouldn't accept non-Lazy monadic types" do
+        expect {
+          lazySquare(Mon::M::Try[5])
+        }.to raise_error(ContractError)
+      end
+    end
+  
+    describe "Future" do
+
+      it "should accept Future monads" do
+        futureSquare(Mon::M::Future.eventually { 5 }).should eql Mon::M::Future[25]
+      end
+
+      it "should accept Promise as well as Complete" do
+        futureSquare(Mon::M::Future.eventually { sleep 1; 5 }).should eql Mon::M::Future[25]
+      end
+
+      it "shouldn't accept Completes of the incorrect type" do
+        expect {
+          futureSquare(Mon::M::FutureComplete["test"])
+        }.to raise_error(ContractError)
+      end
+
+      it "shouldn't accept non-Future types" do
+        expect {
+          futureSquare(5)
+        }.to raise_error(ContractError)
+      end
+      
+      it "shouldn't accept non-Future monadic types" do
+        expect {
+          futureSquare(Mon::M::Try[5])
+        }.to raise_error(ContractError)
+      end      
+    end
+
+    describe "React" do
+
+      it "should accept Reactron monads" do
+        reactSquare(Mon::M::React[5]).should eql Mon::M::React[25]
+      end
+
+      it "should accept Reactors as well as Reactrons" do
+        reactSquare(Mon::M::React[1].bind { |i| i * 5 }).should eql Mon::M::React[25]
+      end
+
+      it "shouldn't accept Reactrons of the incorrect type" do
+        expect {
+          reactSquare(Mon::M::React["test"])
+        }.to raise_error(ContractError)
+      end
+
+      it "shouldn't accept Reactors of the incorrect type" do
+        expect {
+          reactSquare(Mon::M::React["tset"].bind { |s| s.reverse })
+        }.to raise_error(ContractError)
+      end
+
+      it "shouldn't accept non-React types" do
+        expect {
+          reactSquare(5)
+        }.to raise_error(ContractError)
+      end
+      
+      it "shouldn't accept non-React monadic types" do
+        expect {
+          reactSquare(Mon::M::Try[5])
+        }.to raise_error(ContractError)
+      end
+    end
+
+    describe "Monad" do
+
+      it "should accept List" do
+        monadSquare(Mon::M::List[4, 5]).should eql Mon::M::List[16, 25]
+      end
+
+      it "should accept Maybe" do
+        monadSquare(Mon::M::Maybe[5]).should eql Mon::M::Maybe[25]
+      end
+
+      it "should accept None" do
+        monadSquare(Mon::M::None[]).should eql Mon::M::None[]
+      end
+
+      it "should accept Try" do
+        monadSquare(Mon::M::Try.to { 5 }).should eql Mon::M::Success[25]
+      end
+
+      it "should accept Failure" do
+        monadSquare(Mon::M::Try.to { throw RuntimeError.new }).should be_a Mon::M::Failure
+      end
+
+      it "should accept Lazy" do
+        monadSquare(Mon::M::Lazy.eventually { 5 }).should be_a Mon::M::Pending
+      end
+
+      it "should accept Final" do
+        monadSquare(Mon::M::Lazy[5]).should eql Mon::M::Final[25]
+      end
+
+      it "should accept Future" do
+        monadSquare(Mon::M::Future.eventually { sleep 1; 5 }).should eql Mon::M::Future[25]
+      end
+
+      it "should accept FutureComplete" do
+        monadSquare(Mon::M::Future[5]).should eql Mon::M::Future[25]
+      end
+
+      it "should accept React" do
+        monadSquare(Mon::M::React[5]).should eql Mon::M::React[25]
+      end
+
+      it "should accept Reactor" do
+        monadSquare(Mon::M::React[1].bind { |i| i * 5 }).should eql Mon::M::React[25]
+      end
+    end
+
+    describe "Nesting" do
+
+      it "should nest correctly" do
+        tryMaybeSquare(Mon::M::Try[Mon::M::Maybe[5]]).should eql Mon::M::Try[Mon::M::Maybe[25]]
+      end
+
+      it "should nest correctly with other types" do
+        tryStringify(Mon::M::Try[5]).should eql Mon::M::Maybe["We got: 5"]
+        tryStringify(Mon::M::Try["test"]).should eql Mon::M::Maybe["We got: test"]
+      end
+
+      it "should catch improper types in nested values (monad)" do
+        expect {
+          tryMaybeSquare(Mon::M::Try[Mon::M::Maybe["test"]])
+        }.to raise_error(ContractError)
+      end
+
+      it "should catch improper types in nested values (non-monad)" do
+        expect {
+          tryStringify(Mon::M::Try[:some_symbol])
+        }.to raise_error(ContractError)
+      end
+
+      it "should catch massively wrong type errors 1" do
+        expect {
+          tryStringify("test")
+        }.to raise_error(ContractError)
+      end
+      
+      it "should catch massively wrong type errors 2" do
+        expect {
+          tryMaybeSquare("test")
+        }.to raise_error(ContractError)
+      end
+    end
+  end
+
+end