anchor.diff:  end
   ```
   
  -#### Loading an aggregate root object from event store
  +#### Loading an aggregate root object from an event store
   
   ```ruby
   stream_name = "Order$123"
   order = AggregateRoot::Repository.new.load(Order.new, stream_name)
   ```
   
  -To restore the state of your aggregate you need to use `AggregateRoot::Repository`. Repository's `#load` gets all domain events stored for the aggregate in event store stream `Order$123` and applies them to newly created order object in order to rebuild aggregate's state.
  -
  -#### Storing an aggregate root's changes in event store
  +To restore the state of your aggregate you need to use `AggregateRoot::Repository`. Repository's `#load` gets all domain events stored for the aggregate in the event store stream `Order$123` and applies them to the newly created order object in order to rebuild the aggregate's state.
  +
  +#### Storing an aggregate root's changes in an event store
   
   ```ruby
   stream_name = "Order$123"
  
positive.code: end
  ```
  
  You could also privide specific repository for `Order` aggregate to make this code event better:
  
  ```ruby
  class OrderRepository
  
negative.code: end
  ```
  
  The `apply_strategy` method must return a _callable_ that responds to `#call`. We've used lambda in the example above. This lambda takes two arguments -- `aggreate` which in this case is `self` and an `event` being applied.
  
  The `case` statement is one way to implement such a dispatch. The following example shows an equivalent implementation with `Hash`:
  
  ```ruby
  def apply_strategy
  