Primitives shouldn't have pointless #go methods

lib/deferrable_gratification/combinators.rb

@@ -23,7 +23,7 @@ def self.included(base)
 
     module ClassMethods
       def chain(*actions)
-        actions.inject(DG.const(nil).tap(&:go), &:>>)
+        actions.inject(DG.const(nil), &:>>)
       end
     end
   end

lib/deferrable_gratification/primitives.rb

@@ -4,12 +4,27 @@
 
 module DeferrableGratification
   module Primitives
+    # Return a Deferrable which immediately succeeds with a constant value.
     def const(value)
-      Constant.new(value)
+      blank.tap {|d| d.succeed(value) }
     end
 
-    def failure(*args)
-      Failure.new(*args)
+    # Return a Deferrable which immediately fails with an exception.
+    def failure(class_or_message, message_or_nil = nil)
+      blank.tap do |d|
+        d.fail(
+          case class_or_message
+          when Class
+            class_or_message.new(message_or_nil)
+          else
+            RuntimeError.new(class_or_message.to_s)
+          end)
+      end
+    end
+
+    # Return a completely uninteresting Deferrable.
+    def blank
+      DeferrableGratification::DefaultDeferrable.new
     end
   end
 end

spec/deferrable_gratification/combinators/bind_spec.rb

@@ -171,8 +171,8 @@
     # into inner scopes by creating closures).
 
     class << self
-      def good_op(x); DG.const(x).tap(&:go); end
-      def bad_op(*_); DG.failure(RuntimeError, 'Oops').tap(&:go); end
+      def good_op(x); DG.const(x); end
+      def bad_op(*_); DG.failure(RuntimeError, 'Oops'); end
       def transform(x); x.succ; end
       def boom(*_); raise 'Boom!'; end
     end

spec/deferrable_gratification/primitives_spec.rb

@@ -5,10 +5,7 @@
     describe 'DG.const("Hello")' do
       subject { DG.const("Hello") }
 
-      describe 'after #go' do
-        before { subject.go }
-        it { should succeed_with('Hello') }
-      end
+      it { should succeed_with('Hello') }
     end
   end
 
@@ -17,28 +14,19 @@
     describe 'DG.failure("does not compute")' do
       subject { DG.failure("does not compute") }
 
-      describe 'after #go' do
-        before { subject.go }
-        it { should fail_with(RuntimeError, 'does not compute') }
-      end
+      it { should fail_with(RuntimeError, 'does not compute') }
     end
 
     describe 'DG.failure(ArgumentError)' do
       subject { DG.failure(ArgumentError) }
 
-      describe 'after #go' do
-        before { subject.go }
-        it { should fail_with(ArgumentError) }
-      end
+      it { should fail_with(ArgumentError) }
     end
 
     describe 'DG.failure(ArgumentError, "unacceptable command")' do
       subject { DG.failure(ArgumentError, "unacceptable command") }
 
-      describe 'after #go' do
-        before { subject.go }
-        it { should fail_with(ArgumentError, 'unacceptable command') }
-      end
+      it { should fail_with(ArgumentError, 'unacceptable command') }
     end
   end
 end

spec/spec_helper.rb

@@ -33,17 +33,11 @@ def query(*query_parts)
       end
 
       def stub_successful_query(*args)
-        stub(:query).with(*args).and_return do
-          DG.const(yield).
-            tap(&:go)       # TODO
-        end
+        stub(:query).with(*args).and_return { DG.const(yield) }
       end
 
       def stub_failing_query(*args)
-        stub(:query).with(*args).and_return do
-          DG.failure(yield).
-              tap(&:go)     # TODO
-          end
+        stub(:query).with(*args).and_return { DG.failure(yield) }
       end
     end
   end