anchor.diff:  #=> [{"id"=>"abcd", "idMemberCreator"=>"wxyz", "data"=> {...} ...}, ...]
   ```
   
  -The main problem with this approach is that it forces the results to be eager loaded. Unless a max is specified in the method call, we could be waiting for up to 1000 comments to load - 20 requests of 50 - to execute before the results are returned.
  +The main problem with this approach is that it forces the results to be eager loaded. Unless a max is specified in the method call, we could be waiting for up to 1000 comments to load - 20 requests of 50 comments each - to execute before the results are returned.
   
   ### Stop, enumerate, and listen
   
  -We'll refactor our `paginated_get` method to take advantage of Ruby's `Enumerator`. I previous [described Enumerator](/blog/what-is-enumerator.html) and showed how it can be used to [generate infinite sequences in Ruby](/blog/infinite-sequences-in-ruby.html), including [Pascal's Triangle](/blog/pascals-triangle-with-rubys-enumerator.html). The main advantage will be to give callers flexibility to work with the results including filtering, searching, and lazy enumeration.
  -
  -```ruby
  +Next step is to refactor our `paginated_get` method to take advantage of Ruby's `Enumerator`. I previously [described Enumerator](/blog/what-is-enumerator.html) and showed how it can be used to [generate infinite sequences in Ruby](/blog/infinite-sequences-in-ruby.html), including [Pascal's Triangle](/blog/pascals-triangle-with-rubys-enumerator.html).
  +
  +The main advantage of using `Enumerator` will be to give callers flexibility to work with the results including filtering, searching, and lazy enumeration.
  +
  +```ruby
  +MAX = 1000
  +
   def paginated_get(path, options = {})
     Enumerator.new do |y|
       params  = options.dup
       page    = params.delete(:page) { 1 }
  -    max     = params.delete(:max) { 1000 }
  -    total  = 0
  +    limit   = params.fetch(:limit) { 50 }
   
       loop do
         data = get(path, { page: page }.merge(params))
  
positive.code: 
  ### Let's Paginate
  
  Trello provides endpoints for traversing actions taken on boards, cards, and lists. We'll add an alternative method to `get` that can handle pagination.
  
  ```ruby
  def paginated_get(path, options = {})
    params  = options.dup
    max     = params.delete(:max) { 1000 }
    page    = params.delete(:page) { 1 }
    results = []
  
    loop do
  
negative.code: ```ruby
  puts comments.lazy.
     map { |axn| axn["data"]["text"] }.
     select { |txt| txt.start_with?("@personIWorkWith") }.
     take(2).force
  ```
  We may not need to load all 1000 results to because the enumerators chain is evaluated for each item as it is yielded. This technique provides the caller with a great deal of flexibility. Eager loading can be delayed or avoided altogther - a potential performance gain.
  
  Here are magic lines from `#paginated_get`:
  
  ```ruby
  data.each do |element|
  