def call(request)
      reduce(request) { |result, processor|
        begin
          response = processor.call(result)
          return response unless processor.success?(response)
          processor.result(response)
        rescue => exception
          return on_exception(request, result.data, exception)
        end
      }
    end
def call(request)
      reduce(request) { |result, processor|
        begin
          response = processor.call(result)
          return response unless processor.success?(response)
          processor.result(response)
        rescue => exception
          return on_exception(request, result.data, exception)
        end
      }
    end
Call the chain

 Invokes all processors and returns either the first
 {Response::Failure} that it encounters, or if all
 goes well, the {Response::Success} returned from
 the last processor.

 @example

   module App
     SOME_ACTION = Substation::Chain.new [
       Validator.new(MY_VALIDATOR),
       Pivot.new(Actions::SOME_ACTION),
       Presenter.new(Presenters::SomePresenter)
     ]

     env     = Object.new # your env would obviously differ
     input   = { 'name' => 'John' }
     request = Substation::Request.new(env, input)

     response = SOME_ACTION.call(request)

     if response.success?
       response.output # => the output wrapped in a presenter
     else
       response.output # => if validation, pivot or presenter failed
     end
   end

 @param [Request] request
   the request to handle

 @return [Response::Success]
   the response returned from the last processor

 @return [Response::Failure]
   the response returned from the failing processor's failure chain

 @return [Response::Exception]
   the response returned from invoking the {#exception_chain}

 @api public