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: title: Reading events
  ---
  
  ## Specification of read scope
  
  You could use a speciffication 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 name of a stream to read,
     if no stream will be 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 (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 until (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)` - total number of events to read (could be less).
  * `in_batches(batch_size)` - read will be performed in batches of specified size.
     RailsEventStore never reads all domain events at once. Even if you don't specify
     batch size, the read operation will be performed in batches of size 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, i.e.:
  
  ```ruby
  scope = client.read
  
negative.code: 
  ### Reading all events forward
  
  This method allows us to load all stored events in ascending order.
  
  This will read first 100 domain events stored in the event store.
  
  ```ruby
  client.read.limit(100).to_a
  ```
  
  When not specified, it reads events starting from the first domain event
  stored in the event store, with no limit applied.
  
  ```ruby
  client.read.to_a
  ```
  
  You can 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
  