Async::Enumerable

# Before: ☕ Time for coffee...
users = user_ids.map { |id| fetch_user(id) }  # 30 seconds for 30 users

# After: ⚡ Lightning fast!
users = user_ids.async.map { |id| fetch_user(id) }  # 1 second for 30 users!

require 'async/enumerable'

# Transform any enumerable into something useful
results = [1, 2, 3, 4, 5].async.map { |n| slow_api_call(n) }
# => [2, 4, 6, 8, 10]  (but in 1 second instead of 5)

# Works with anything Enumerable
(1..1000).async.select { |n| check_api(n) }  # Hit all the APIs at once
Set[*urls].async.map { |url| fetch(url) }

require 'async/enumerable'
require 'net/http'
require 'json'

coffee_shops = [
  { name: "Starbucks", api: "https://api.github.com/users/starbucks" },
  { name: "Blue Bottle", api: "https://api.github.com/users/bluebottle" },
  { name: "Philz", api: "https://api.github.com/users/philz" },
  { name: "Peet's", api: "https://api.github.com/users/peets" },
  { name: "Dunkin'", api: "https://api.github.com/users/dunkin" }
]

# The slow way
start = Time.now
shop_data = coffee_shops.map do |shop|
  response = Net::HTTP.get(URI(shop[:api]))
  { shop[:name] => JSON.parse(response)["public_repos"] rescue 0 }
end
puts "Sequential: #{Time.now - start} seconds"  # Go get coffee

# The async way (like you have better things to do)
start = Time.now
shop_data = coffee_shops.async.map do |shop|
  response = Net::HTTP.get(URI(shop[:api]))
  { shop[:name] => JSON.parse(response)["public_repos"] rescue 0 }
end
puts "Parallel: #{Time.now - start} seconds"  # Already done

rooms = [
  { name: "Kitchen", search_time: 0.3 },
  { name: "Bedroom", search_time: 0.1 },  
  { name: "Garage", search_time: 0.5 },
  { name: "Living Room", search_time: 0.2 }
]

# Sequential search - always searches rooms in order
found = rooms.find do |room|
  sleep(room[:search_time])  # Simulate searching
  room[:name] == "Bedroom"
end
# Always takes 0.4 seconds (Kitchen + Bedroom)

# Async search - everyone searches at once!
found = rooms.async.find do |room|
  sleep(room[:search_time])  # Simulate searching  
  room[:name] == "Bedroom"
end
# Takes only 0.1 seconds! (Bedroom finishes first)

# With larger collections, early termination really shines:
servers = 100.times.map { |i| "server-#{i}" }

# Check servers for the one with our data
found = servers.async(max_fibers: 10).find do |server|
  response = check_server(server)  # 0.5-2 seconds each
  response[:has_data]
end
# Stops checking as soon as one server responds with data!
# The other fibers are cancelled, saving time and resources.

class EmailValidator
  include Async::Enumerable
  def_async_enumerable :@checks
  
  def initialize(email)
    @email = email
    @checks = [
      -> { check_dns_record },        # 0.5 seconds
      -> { check_disposable_domain }, # 0.3 seconds  
      -> { check_smtp_verify },       # 1.0 seconds
      -> { check_reputation }         # 0.4 seconds
    ]
  end
  
  def valid?
    # All checks must pass - but run them in parallel!
    @checks.async.all? { |check| check.call }
    # Total time: ~1.0 seconds (the slowest check)
    # Sequential would be: 2.2 seconds
  end
  
  def suspicious?
    # Stops as soon as ANY check fails
    @checks.async.any? { |check| !check.call }
  end
end

# Processing a bunch of user records
users = User.all  # Let's say 1000 users

results = users
  .async(max_fibers: 50)  # Be nice to the database
  .select { |u| u.active? }  # Parallel filtering
  .map { |u| enrich_with_api_data(u) }  # Parallel API calls
  .reject { |u| u.data[:score] < 0.5 }  # Parallel scoring
  .sort_by { |u| -u.data[:score] }  # Sort by score
  .take(100)  # Top 100 users

# Each step runs in parallel, but waits for completion before the next step.
# Still way faster than sequential!

class GitHubScraper
  include Async::Enumerable
  def_async_enumerable :@repos, max_fibers: 10  # GitHub rate limit friendly
  
  def initialize(org)
    @repos = fetch_repo_list(org)
  end
  
  def analyze_repos
    @repos.async.map do |repo|
      # These run in parallel, but max 10 at a time
      data = fetch_repo_details(repo)
      {
        name: repo,
        stars: data["stargazers_count"],
        language: data["language"],
        last_update: data["updated_at"]
      }
    end
  end
end

# Scrape responsibly!
scraper = GitHubScraper.new("ruby")
repo_analysis = scraper.analyze_repos  # Fast but respectful

# Every Enumerable method you know and love:
[1, 2, 3].async.map { |n| expensive_calc(n) }     # ⚡ Parallel map
[1, 2, 3].async.select { |n| slow_check(n) }      # ⚡ Parallel select  
[1, 2, 3].async.any? { |n| api_check(n) }         # ⚡ Stops when found!
[1, 2, 3].async.find { |n| database_lookup(n) }   # ⚡ First to finish wins!

# Chain them together:
data.async
  .select { |x| x.valid? }        # Parallel filtering
  .map { |x| transform(x) }       # Parallel transformation
  .reduce(0) { |sum, x| sum + x } # Even reduce works!

class TodoList
  include Async::Enumerable
  def_async_enumerable :@todos  # Tell it what to enumerate
  
  def initialize
    @todos = []
  end
  
  def <<(todo)
    @todos << todo
    self
  end
end

list = TodoList.new
list << "Buy coffee" << "Write code" << "Ship it!"

# Now your class has async!
list.async.map { |todo| complete_todo(todo) }

# This is actually a feature, not a bug!
[slow_api, fast_api, medium_api].async.find { |api| api.has_data? }
# Returns fast_api's data (even though it's second in the array)

async_result = [1, 2, 3].async.map { |x| x * 2 }
async_result == [2, 4, 6]  # => true!

# Perfect for testing:
expect(data.async.select(&:valid?)).to eq(expected_items)

# GOOD: I/O bound operations
urls.async.map { |url| HTTP.get(url) }  # 🚀 Much faster!

# BAD: CPU-bound calculations
numbers.async.map { |n| n * 2 }  # 🐢 Slower (fiber overhead)

# GOOD: I/O operations
files.async.map { |f| File.read(f) }  # 🚀 Parallel I/O!

# BAD: Sequential operations
data.async.map { |x| @sum += x }  # ❌ Don't do this!

# Processing 10,000 items? Control your fibers:
(1..10000).async(max_fibers: 100).map { |n| process(n) }

# Set a default for your class:
class DataProcessor
  include Async::Enumerable
  def_async_enumerable :@items, max_fibers: 50
end