anchor.diff:  client.read.backward.stream(stream_name).from(start).limit(count).to_a
   ```
   
  -### Reading all events from stream forward
  +### Reading all events from a stream forward
   
  -This method allows us to load all stream's events ascending.
  +This method allows us to load all of a stream's events in ascending order.
   
   ```ruby
   stream_name = "order_1"
   client.read.stream(stream_name).to_a
   ```
   
  -### Reading all events from stream backward
  +### Reading all events from a stream backward
   
  -This method allows us to load all stream's events descending.
  +This method allows us to load all of a stream's events in descending order.
   
   ```ruby
   stream_name = "order_1"
  
positive.code: 
  ### Reading all events forward
  
  This method allows us to load all stored events ascending.
  
  This will read first 100 domain events stored in event store.
  
  ```ruby
  client.read.limit(100).to_a
  ```
  
  When not specified otherwise it reads events starting from first domain event
  stored in event store and without limit.
  
  ```ruby
  client.read.to_a
  ```
  
  You could also read batch of domain events starting from any read or published event.
  
  ```ruby
  client.read.from(last_read_event.event_id).limit(100).to_a
  
negative.code: title: Reading events
  ---
  
  ## Specifying read scope
  
  You could use a specification pattern to prepare a read scope.
  The read scope defines what domain events will be read.
  
  The available specification methods are:
  
  * `stream(stream_name)` - specify the name of a stream to read.
     If no stream is specified, a global stream (all domain events)
     will be read.
  * `from(start)` - specify the starting point (event id) for read operation. 
     This will read all domain events after (but not including) the specified domain event id.
  * `to(stop)` - specify the stop point (event id) for the read operation. This will
     read all domain events up until (but not including) the specified domain event id.
  * `forward` - reading direction, from oldest to newest domain events.
  * `backward` - reading direction, from newest to oldest  domain events.
  * `limit(count)` - maximum number of events to read.
  * `in_batches(batch_size)` - read will be performed in batches of the specified size.
     RailsEventStore never reads all domain events at once. Even if you don't specify
     a batch size, the read operation will be performed in batches of 100.
  * `of_type(types)` - read only specified types of domain events, ignoring all others.
  
  The read scope could be defined by chaining the specification methods, e.g.:
  
  ```ruby
  scope = client.read
  