Frameworks

Performance Optimization Comparison

Vanilla PHP caching approach:

// Vanilla PHP - Manual caching implementation
function getUserData($userId) {
    $cacheFile = 'cache/user_' . $userId . '.cache';
    
    if (file_exists($cacheFile) && (time() - filemtime($cacheFile) < 3600)) {
        return unserialize(file_get_contents($cacheFile));
    }
    
    // Database query
    $db = new PDO('mysql:host=localhost;dbname=app', 'user', 'password');
    $stmt = $db->prepare('SELECT * FROM users WHERE id = ?');
    $stmt->execute([$userId]);
    $data = $stmt->fetch(PDO::FETCH_ASSOC);
    
    // Store in cache
    file_put_contents($cacheFile, serialize($data));
    
    return $data;
}
        

Laravel caching approach:

// Laravel - Using the Cache facade
use Illuminate\Support\Facades\Cache;

function getUserData($userId) {
    return Cache::remember('user:' . $userId, 3600, function () use ($userId) {
        return User::find($userId);
    });
}
        

Architectural Flow in Laravel Directory Structure:

// 1. Request enters via public/index.php front controller
require __DIR__.'/../bootstrap/autoload.php';
$app = require_once __DIR__.'/../bootstrap/app.php';

// 2. Routes defined in routes/web.php
Route::get('/users', [UserController::class, 'index']);

// 3. Controller in app/Http/Controllers/UserController.php
public function index()
{
    $users = User::all(); // Model interaction
    return view('users.index', compact('users')); // View rendering
}

// 4. Model in app/Models/User.php
class User extends Authenticatable
{
    // Relationships, attributes, query scopes
}

// 5. View in resources/views/users/index.blade.php
@foreach($users as $user)
    {{ $user->name }}
@endforeach
        

Route Definition Anatomy:

Route::get('profile/{id}', [ProfileController::class, 'show'])
    ->middleware('auth')
    ->name('profile.show')
    ->where('id', '[0-9]+');
        

Route Dispatching Internals:

// Simplified internals of route matching
$request = Request::capture();
$router = app(Router::class);

// Find route that matches the request
$route = $router->getRoutes()->match($request);

// Execute middleware stack
$response = $router->prepareResponse(
    $request, 
    $route->run($request)
);
        

Parameter Constraints and Validation:

// Using the where method for inline constraints
Route::get('users/{id}', [UserController::class, 'show'])
    ->where('id', '[0-9]+');

// Global pattern constraints in RouteServiceProvider
public function boot()
{
    Route::pattern('id', '[0-9]+');
    // ...
}

// Custom parameter binding with explicit model resolution
Route::bind('user', function ($value) {
    return User::where('username', $value)
        ->firstOrFail();
});

// Implicit model binding with custom resolution logic
Route::get('users/{user:username}', function (User $user) {
    // $user is resolved by username instead of ID
});
        

Advanced Named Route Techniques:

// Generating URLs with query parameters
$url = route('users.index', [
    'search' => 'John',
    'filter' => 'active',
]);

// Accessing the current route name
if (Route::currentRouteName() === 'users.show') {
    // Logic for the users.show route
}

// Checking if a route exists
if (Route::has('api.users.show')) {
    // The route exists
}

// URL generation for signed routes (tamper-proof URLs)
$url = URL::signedRoute('unsubscribe', ['user' => 1]);

// Temporary signed routes with expiration
$url = URL::temporarySignedRoute(
    'confirm-registration',
    now()->addMinutes(30),
    ['user' => 1]
);
        

Advanced Route Grouping Techniques:

// Domain routing for multi-tenant applications
Route::domain('tenant.{account}.example.com')->group(function () {
    Route::get('/', function ($account) {
        // $account will be the subdomain segment
    });
});

// Route group with rate limiting
Route::middleware([
    'auth:api',
    'throttle:60,1' // 60 requests per minute
])->prefix('api/v1')->group(function () {
    // API routes
});

// Controller groups with namespace (Laravel < 8)
Route::namespace('Admin')->prefix('admin')->group(function () {
    // Controllers in App\Http\Controllers\Admin namespace
});

// Conditional route registration
Route::middleware('auth')->group(function () {
    if (config('features.notifications')) {
        Route::get('notifications', [NotificationController::class, 'index']);
    }
});
        

// In a ModuleServiceProvider
public function boot()
{
    $this->loadRoutesFrom(__DIR__ . '/../routes/module.php');
}
        

Advanced Controller Implementation with Multiple Concerns:

namespace App\Http\Controllers;

use App\Http\Requests\StoreUserRequest;
use App\Models\User;
use App\Services\UserService;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Log;

class UserController extends Controller
{
    protected $userService;
    
    // Constructor injection
    public function __construct(UserService $userService)
    {
        $this->userService = $userService;
        // Apply middleware only to specific methods
        $this->middleware('auth')->only(['store', 'update', 'destroy']);
        $this->middleware('role:admin')->except(['index', 'show']);
    }
    
    // Type-hinted dependency injection in method
    public function store(StoreUserRequest $request): JsonResponse
    {
        try {
            // Request is automatically validated due to form request type
            $user = $this->userService->createUser($request->validated());
            return response()->json(['user' => $user, 'message' => 'User created'], 201);
        } catch (\Exception $e) {
            Log::error('User creation failed: ' . $e->getMessage());
            return response()->json(['error' => 'Failed to create user'], 500);
        }
    }
    
    // Route model binding via type-hint
    public function show(User $user)
    {
        // $user is automatically fetched by ID from the route parameter
        return view('users.show', compact('user'));
    }
}
    

Resource Controller with Model Binding and API Resources:

namespace App\Http\Controllers;

use App\Http\Resources\ProductResource;
use App\Http\Resources\ProductCollection;
use App\Models\Product;
use App\Http\Requests\ProductStoreRequest;
use App\Http\Requests\ProductUpdateRequest;

class ProductController extends Controller
{
    public function index()
    {
        $products = Product::paginate(15);
        return new ProductCollection($products);
    }

    public function store(ProductStoreRequest $request)
    {
        $product = Product::create($request->validated());
        return new ProductResource($product);
    }

    public function show(Product $product) // Implicit route model binding
    {
        return new ProductResource($product);
    }

    public function update(ProductUpdateRequest $request, Product $product)
    {
        $product->update($request->validated());
        return new ProductResource($product);
    }

    public function destroy(Product $product)
    {
        $product->delete();
        return response()->noContent();
    }
}
    

HTTP Request
  ↓
Route Matching
  ↓
Global Middleware (app/Http/Kernel.php)
  ↓
Route Group Middleware
  ↓
Controller Middleware
  ↓
Controller Method
  ↓
Response
  ↓
Middleware (in reverse order)
  ↓
HTTP Response
    

View Service Provider Registration:

// The ViewServiceProvider bootstraps the entire view system
namespace Illuminate\View\Providers;

class ViewServiceProvider extends ServiceProvider
{
    public function register()
    {
        $this->registerFactory();
        $this->registerViewFinder();
        $this->registerEngineResolver();
    }
}
        

Blade Compilation Internals:

// From Illuminate\View\Compilers\BladeCompiler
protected function compileStatements($content)
{
    // Pattern matching for all registered directives
    return preg_replace_callback(
        '/\B@(\w+)([ \t]*)(\( ( (?>[^()]+) | (?3) )* \))?/x',
        function ($match) {
            return $this->compileStatement($match);
        },
        $content
    );
}
        

Custom Blade Directive Registration:

// In a service provider
public function boot()
{
    Blade::directive('datetime', function ($expression) {
        return "format('m/d/Y H:i'); ?>";
    });
}

// Usage in Blade template
@datetime($user->created_at)
        

Directive Registration Mechanism:

// From BladeServiceProvider
public function boot()
{
    $blade = $this->app['view']->getEngineResolver()->resolve('blade')->getCompiler();
    
    // Core directive registration
    $blade->directive('if', function ($expression) {
        return "";
    });
    
    // Custom directive example
    $blade->directive('datetime', function ($expression) {
        return "format('Y-m-d H:i:s'); ?>";
    });
}
        

Multi-level Inheritance:

// Master layout (resources/views/layouts/master.blade.php)
<html>
<head>
    <title>@yield('site-title') - @yield('page-title', 'Default')</title>
    @yield('meta')
    @stack('styles')
</head>
<body>
    @include('partials.header')
    
    <div class="container">
        @yield('content')
    </div>
    
    @include('partials.footer')
    @stack('scripts')
</body>
</html>

// Intermediate layout (resources/views/layouts/admin.blade.php)
@extends('layouts.master')

@section('site-title', 'Admin Panel')

@section('meta')
    <meta name="robots" content="noindex">
    @parent
@endsection

@section('content')
    <div class="admin-container">
        <div class="sidebar">
            @include('admin.sidebar')
        </div>
        <div class="main">
            @yield('admin-content')
        </div>
    </div>
@endsection

@push('scripts')
    <script src="{{ asset('js/admin.js') }}"></script>
@endpush

// Page view (resources/views/admin/dashboard.blade.php)
@extends('layouts.admin')

@section('page-title', 'Dashboard')

@section('admin-content')
    <h1>Admin Dashboard</h1>
    <div class="dashboard-widgets">
        @each('admin.widgets.card', $widgets, 'widget', 'admin.widgets.empty')
    </div>
@endsection

@prepend('scripts')
    <script src="{{ asset('js/dashboard.js') }}"></script>
@endprepend
        

Class-based Component:

// App\View\Components\Alert.php
namespace App\View\Components;

use Illuminate\View\Component;

class Alert extends Component
{
    public $type;
    public $message;
    
    public function __construct($type, $message)
    {
        $this->type = $type;
        $this->message = $message;
    }
    
    public function render()
    {
        return view('components.alert');
    }
    
    // Computed property
    public function alertClasses()
    {
        return 'alert alert-' . $this->type;
    }
}

// resources/views/components/alert.blade.php
<div class="{{ $alertClasses }}">
    <div class="alert-title">{{ $title ?? 'Notice' }}</div>
    <div class="alert-body">{{ $message }}</div>
    {{ $slot }}
</div>

// Usage
<x-alert type="error" message="System error occurred">
    <p>Please contact support.</p>
</x-alert>
        

Customizing Model Configuration:

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Product extends Model
{
    // Custom table name
    protected $table = 'inventory_items';
    
    // Custom primary key
    protected $primaryKey = 'product_id';
    
    // Disable auto-timestamps
    public $timestamps = false;
    
    // Custom connection
    protected $connection = 'inventory_db';
    
    // Mass assignment protection
    protected $fillable = ['name', 'price', 'description'];
    protected $guarded = ['product_id', 'admin_notes'];
    
    // Default attribute values
    protected $attributes = [
        'is_active' => true,
        'stock' => 0
    ];
}
        

Advanced Eloquent Query Techniques:

// Subqueries in Eloquent
$users = User::addSelect([
    'last_order_date' => Order::select('created_at')
        ->whereColumn('user_id', 'users.id')
        ->latest()
        ->limit(1)
])->get();

// Complex joins with constraints
$posts = Post::with(['comments' => function($query) {
    $query->where('is_approved', true);
}])
->whereHas('comments', function($query) {
    $query->where('rating', '>', 4);
}, '>=', 3)
->get();

// Querying JSON columns
$users = User::where('preferences->theme', 'dark')
             ->whereJsonContains('roles', 'admin')
             ->get();
        

Creation Methods and Their Internals:

// Standard creation pattern
$post = new Post;
$post->title = 'Advanced Eloquent';
$post->content = 'Content here...';
$post->save(); // Triggers created/saved events, performs insert query

// Mass assignment with protection
$post = Post::create([
    'title' => 'Advanced Eloquent',
    'content' => 'Content here...'
]); // Checks $fillable/$guarded, triggers events, returns instance

// createOrFirst with unique constraints
$post = Post::firstOrCreate(
    ['slug' => 'advanced-eloquent'], // Unique constraint fields
    ['title' => 'Advanced Eloquent', 'content' => 'Content'] // Additional fields
); // Performs SELECT first, INSERT only if needed

// Inserting multiple records efficiently
Post::insert([
    ['title' => 'Post 1', 'content' => 'Content 1'],
    ['title' => 'Post 2', 'content' => 'Content 2'],
]); // Bulk insert without creating model instances or firing events

// Create with relationships
$post = User::find(1)->posts()->create([
    'title' => 'My New Post',
    'content' => 'Content here...'
]); // Automatically sets the foreign key
        

// Query building with advanced conditions
$posts = Post::where(function($query) {
    $query->where('status', 'published')
          ->orWhere(function($query) {
              $query->where('status', 'draft')
                    ->where('user_id', auth()->id());
          });
})
->whereHas('comments', function($query) {
    $query->where('is_approved', true);
}, '>', 5) // Posts with more than 5 approved comments
->withCount([
    'comments', 
    'comments as approved_comments_count' => function($query) {
        $query->where('is_approved', true);
    }
])
->with(['user' => function($query) {
    $query->select('id', 'name');
}])
->latest()
->paginate(15);

// Raw expressions
$posts = Post::selectRaw('COUNT(*) as post_count, DATE(created_at) as date')
             ->whereRaw('YEAR(created_at) = ?', [date('Y')])
             ->groupBy('date')
             ->orderByDesc('date')
             ->get();

// Chunk processing for large datasets
Post::where('needs_processing', true)
    ->chunkById(100, function($posts) {
        foreach ($posts as $post) {
            // Process each post
            $post->update(['processed' => true]);
        }
    });
        

// Efficient increment/decrement
Post::where('id', 1)->increment('views', 1, ['last_viewed_at' => now()]);

// Conditional updates
$post = Post::find(1);
$post->title = 'New Title';
// Only save if the model has changed
if ($post->isDirty()) {
    // Get which attributes changed
    $changes = $post->getDirty();
    $post->save();
}

// Using updateOrCreate for upserts
$post = Post::updateOrCreate(
    ['slug' => 'unique-slug'], // Fields to match
    ['title' => 'Updated Title', 'content' => 'Updated content'] // Fields to update/create
);

// Touching timestamps on relationships
$user = User::find(1);
// Update user's updated_at and all related posts' updated_at
$user->touch();
$user->posts()->touch();

// Mass update with JSON columns
Post::where('id', 1)->update([
    'title' => 'New Title',
    'metadata->views' => DB::raw('metadata->views + 1'),
    'tags' => DB::raw('JSON_ARRAY_APPEND(tags, '$', "new-tag")')
]);
        

// Soft deletes
// First ensure your model uses SoftDeletes trait and migration includes deleted_at
use Illuminate\Database\Eloquent\SoftDeletes;

class Post extends Model
{
    use SoftDeletes;
    // ...
}

// Working with soft deletes
$post = Post::find(1);
$post->delete(); // Soft delete - sets deleted_at column
Post::withTrashed()->get(); // Get all posts including soft deleted
Post::onlyTrashed()->get(); // Get only soft deleted posts
$post->restore(); // Restore a soft deleted post
$post->forceDelete(); // Permanently delete

// Cascading deletes through relationships
// In your User model:
public function posts()
{
    return $this->hasMany(Post::class);
}

// Option 1: Using deleting event
public static function boot()
{
    parent::boot();
    
    static::deleting(function($user) {
        $user->posts()->delete();
    });
}

// Option 2: Using onDelete cascade in migration
Schema::create('posts', function (Blueprint $table) {
    // ...
    $table->foreignId('user_id')
          ->constrained()
          ->onDelete('cascade');
});
        

// Basic transaction
DB::transaction(function () {
    $post = Post::create(['title' => 'New Post']);
    Comment::create([
        'post_id' => $post->id,
        'content' => 'First comment!'
    ]);
    // If any exception occurs, the transaction will be rolled back
});

// Manual transaction control
try {
    DB::beginTransaction();
    
    $post = Post::create(['title' => 'New Post']);
    
    if (someCondition()) {
        Comment::create([
            'post_id' => $post->id,
            'content' => 'First comment!'
        ]);
    }
    
    DB::commit();
} catch (\Exception $e) {
    DB::rollBack();
    throw $e;
}

// Transaction with deadlock retry
DB::transaction(function () {
    // Operations that might cause deadlocks
}, 5); // Will retry up to 5 times on deadlock
        

Advanced Pattern: Labeled Control Flow

Go supports labeled break and continue statements for more complex control flow:

OuterLoop:
    for i := 0; i < 10; i++ {
        for j := 0; j < 10; j++ {
            if i*j > 50 {
                fmt.Println("Breaking outer loop")
                break OuterLoop // Breaks out of both loops
            }
            if j > 5 {
                continue OuterLoop // Skips to next iteration of outer loop
            }
        }
    }
        

If statement with initialization:

// The initialization statement (before the semicolon) creates variables 
// scoped only to the if-else blocks
if file, err := os.Open("file.txt"); err != nil {
    // Error handling using the err variable
    log.Printf("error opening file: %v", err)
} else {
    // Success case using the file variable
    defer file.Close()
    // Process file...
}
// file and err are not accessible here

// This pattern is idiomatic in Go for error handling
if err := someFunction(); err != nil {
    return fmt.Errorf("context: %w", err) // Using error wrapping
}
        

Advanced switch cases:

// Switch with initialization
switch os := runtime.GOOS; os {
case "darwin":
    fmt.Println("macOS")
case "linux":
    fmt.Println("Linux")
default:
    fmt.Printf("%s\n", os)
}

// Type switches - powerful for interface type assertions
func printType(v interface{}) {
    switch x := v.(type) {
    case nil:
        fmt.Println("nil value")
    case int, int8, int16, int32, int64:
        fmt.Printf("Integer: %d\n", x)
    case float64:
        fmt.Printf("Float64: %g\n", x)
    case func(int) float64:
        fmt.Printf("Function that takes int and returns float64\n")
    case bool:
        fmt.Printf("Boolean: %t\n", x)
    case string:
        fmt.Printf("String: %s\n", x)
    default:
        fmt.Printf("Unknown type: %T\n", x)
    }
}

// Using fallthrough to continue to next case
switch n := 4; n {
case 0:
    fmt.Println("is zero")
case 1, 2, 3, 4, 5:
    fmt.Println("is between 1 and 5")
    fallthrough // Will execute the next case regardless of its condition
case 6, 7, 8, 9:
    fmt.Println("is between 1 and 9")
}
// Outputs: "is between 1 and 5" and "is between 1 and 9"
        

Loop with labels and control flow:

// Using labels for breaking out of nested loops
OuterLoop:
    for i := 0; i < 10; i++ {
        for j := 0; j < 10; j++ {
            if i*j > 50 {
                fmt.Printf("Breaking at i=%d, j=%d\n", i, j)
                break OuterLoop
            }
        }
    }

// Loop control with continue
for i := 0; i < 10; i++ {
    if i%2 == 0 {
        continue // Skip even numbers
    }
    fmt.Println(i) // Print odd numbers
}

// Effective use of defer in loops
for _, file := range filesToProcess {
    // Each deferred Close() will execute when its containing function returns,
    // not when the loop iteration ends
    if f, err := os.Open(file); err == nil {
        defer f.Close() // Potential resource leak if many files!
        // Better approach for many files:
        // Process file and close immediately in each iteration
    }
}
        

Range expression evaluation and value copying:

// Understanding that range creates copies
type Person struct {
    Name string
    Age  int
}

people := []Person{
    {"Alice", 30},
    {"Bob", 25},
    {"Charlie", 35},
}

// The Person objects are copied into 'person'
for _, person := range people {
    person.Age += 1 // This does NOT modify the original slice
}

fmt.Println(people[0].Age) // Still 30, not 31

// To modify the original:
for i := range people {
    people[i].Age += 1
}

// Or use pointers:
peoplePtr := []*Person{
    {"Alice", 30},
    {"Bob", 25},
}

for _, p := range peoplePtr {
    p.Age += 1 // This DOES modify the original objects
}
        

Range over channels:

// Range over channels for concurrent programming
ch := make(chan int)

go func() {
    for i := 0; i < 5; i++ {
        ch <- i
    }
    close(ch) // Important: close channel when done sending
}()

// Range receives values until channel is closed
for num := range ch {
    fmt.Println(num)
}
        

Performance patterns:

// Pre-allocating slices when building results in loops
items := []int{1, 2, 3, 4, 5}
result := make([]int, 0, len(items)) // Pre-allocate capacity

for _, item := range items {
    result = append(result, item*2)
}

// Efficient string iteration
s := "Hello, 世界" // Unicode string with multi-byte characters

// Byte iteration (careful with Unicode!)
for i := 0; i < len(s); i++ {
    fmt.Printf("%d: %c (byte)\n", i, s[i])
}

// Rune iteration (proper Unicode handling)
for i, r := range s {
    fmt.Printf("%d: %c (rune at byte position %d)\n", i, r, i)
}
        

Metaprogramming Example:

# Dynamic method generation with Ruby metaprogramming
class Product
  # Automatically create getter/setter methods
  attr_accessor :name, :price
  
  # Define methods dynamically based on a list
  ["available?", "discontinued?", "on_sale?"].each do |method_name|
    define_method(method_name) do
      # Implementation would vary based on the method
      status = method_name.to_s.chomp("?")
      instance_variable_get("@#{status}") == true
    end
  end
  
  # Method missing for dynamic property access
  def method_missing(method, *args)
    if method.to_s =~ /find_by_(.+)/
      attribute = $1
      self.class.all.find { |p| p.send(attribute) == args.first }
    else
      super
    end
  end
end
        

Core Syntax Elements:

# Expression orientation - everything returns a value
result = if x > 10
          "Greater"
        else
          "Lesser"
        end

# Statement modifiers for concise conditionals
puts "It's cold" if temperature < 0

# Method calls allow parentheses omission
puts "Hello"       # No parentheses
puts("Hello")      # With parentheses

# Built-in language constructs look like methods
5.times { |i| puts i }   # Iteration via method-like syntax
[1, 2, 3].map(&:to_s)    # Symbol-to-proc conversion

# Multiple return values without explicit tuples
def coordinates
  [x, y, z]
end
x, y, z = coordinates  # Parallel assignment
        

Ruby's Unique Syntactic Constructs:

# Case expressions with pattern matching (Ruby 2.7+)
case input
when [Integer, Integer] => [x, y]
  puts "Coordinates: #{x}, #{y}"
when String => name if name.start_with?("A")
  puts "Name starts with A: #{name}"
when { name: String => name, age: Integer => age }
  puts "Person: #{name}, #{age} years old"
else
  puts "Unrecognized pattern"
end

# Keyword arguments vs positional arguments
def configure(host:, port: 80, **options)
  # Named parameters with defaults and collection
end

# Block local variables
[1, 2, 3].each_with_index do |value, index; temp|
  # temp is local to this block
  temp = value * index
  puts temp
end
        

# Integer automatically handles arbitrary precision
factorial = 1
100.times { |i| factorial *= (i+1) }
puts factorial  # Massive number handled without overflow

# Float precision issues
0.1 + 0.2 == 0.3  # => false (returns 0.30000000000000004)

# Rational for exact arithmetic
r1 = Rational(1, 3)  # => (1/3)
r2 = Rational(2, 5)  # => (2/5)
r1 + r2  # => (11/15) - exact representation

# Complex numbers
c = Complex(2, 3)  # => (2+3i)
c * c  # => (2+3i)*(2+3i) = 4+12i-9 = (-5+12i)
        

# String encoding handling
str = "こんにちは"  # UTF-8 encoded by default
str.encoding  # => #<Encoding:UTF-8>
str.bytes     # => [227, 129, 147, 227, 130, 147, 227, 129, 171, 227, 129, 161, 227, 129, 175]

# String immutability comparison
str = "hello"
str_id = str.object_id
str << " world"  # Mutates in place
str.object_id == str_id  # => true (same object)

str = "hello"
str_id = str.object_id
str = str + " world"  # Creates new object
str.object_id == str_id  # => false (different object)
        

# Symbol internalization
sym1 = :status
sym2 = :status
sym1.object_id == sym2.object_id  # => true (same object in memory)

str1 = "status"
str2 = "status"
str1.object_id == str2.object_id  # => false (different objects)

# Memory usage comparison
require 'benchmark/memory'

Benchmark.memory do |x|
  x.report("10000 strings") { 
    10000.times.map { |i| "string_#{i}" }
  }
  
  x.report("10000 symbols") { 
    10000.times.map { |i| :"symbol_#{i}" }
  }
end
# Symbols consume less memory but are never garbage collected
        

# Array internals
# Ruby arrays resize exponentially to amortize reallocation costs
a = []
a.capacity  # Not a real method, but internally arrays have capacity > size

# Hash implementation changed in Ruby 2.0+ for improved DoS protection
# Ruby uses open addressing with quadratic probing instead of linked lists
h = {a: 1, b: 2}
h.compare_by_identity  # Changes comparison semantics to use object_id

# Performance characteristics
require 'benchmark'
n = 1_000_000
hash = Hash.new
array = []

n.times { |i| hash[i] = i; array[i] = i }

Benchmark.bm do |x|
  x.report("Hash lookup") { hash[n/2] }
  x.report("Array lookup") { array[n/2] }
end
# Hash lookup is O(1), array index lookup is also O(1)
        

# Numeric class hierarchy
# Numeric → Integer → (Fixnum/Bignum, now unified)
# Numeric → Float
# Numeric → Rational
# Numeric → Complex

# Automatic type conversion and precision handling
result = 1 / 2          # Integer division: 0
result = 1.0 / 2        # Float division: 0.5
result = Rational(1, 2) # Rational: (1/2)

# Arbitrary-precision arithmetic (seamless big number handling)
factorial = (1..100).inject(:*) # Computes 100! without overflow

# Numeric coercion protocol
# Ruby uses method_missing and coerce to handle mixed-type operations
class Dollars
  attr_reader :amount
  def initialize(amount)
    @amount = amount
  end
  
  def +(other)
    if other.is_a?(Dollars)
      Dollars.new(@amount + other.amount)
    else
      # Uses coercion protocol
      self + Dollars.new(other)
    end
  end
  
  def coerce(other)
    # Return [other_as_my_type, self] for a + b operations
    [Dollars.new(other), self]
  end
end

money = Dollars.new(100)
result = 50 + money  # Works via coercion protocol
        

# String implementation details
# - Mutable byte arrays with encoding metadata
# - Copy-on-write optimization (implementation dependent)
# - Ropes data structure in some Ruby implementations

# Encodings support
str = "こんにちは"
str.encoding         # => #<Encoding:UTF-8>
str.force_encoding("ASCII-8BIT")  # Changes the interpretation, not the bytes

# String interning and memory optimization
str1 = "hello".freeze   # Freezing prevents modification
str2 = "hello".freeze   # In Ruby 2.3+, identical frozen strings may share storage

# Performance comparison: string concatenation
require 'benchmark'

Benchmark.bm do |x|
  x.report("String#+") {
    s = ""
    10000.times { s = s + "x" }  # Creates 10000 intermediary strings
  }
  
  x.report("String#<<") {
    s = ""
    10000.times { s << "x" }     # Modifies in place, no intermediary strings
  }
  
  x.report("Array join") {
    a = []
    10000.times { a << "x" }
    s = a.join                   # Often more efficient for many pieces
  }
end

# String slicing with different parameters
str = "Ruby programming"
str[0]       # => "R" (single index returns character)
str[0, 4]    # => "Ruby" (index and length)
str[5..15]   # => "programming" (range)
str[/R.../]  # => "Ruby" (regex match)
str["Ruby"]  # => "Ruby" (substring match)
        

# Symbol table implementation
# - Global VM symbol table for uniqueness
# - Identity comparison is O(1) (pointer comparison)
# - Prior to Ruby 2.2, symbols were never garbage collected

# Performance comparison
require 'benchmark'

Benchmark.bm do |x|
  strings = Array.new(100000) { |i| "string_#{i}" }
  symbols = Array.new(100000) { |i| :"symbol_#{i}" }
  
  x.report("String comparison") {
    strings.each { |s| s == "string_50000" }
  }
  
  x.report("Symbol comparison") {
    symbols.each { |s| s == :symbol_50000 }
  }
end
# Symbol comparison is significantly faster due to pointer equality

# Symbol garbage collection in Ruby 2.2+
GC::INTERNAL_CONSTANTS[:SYMBOL_GC_ENABLE]  # => true in newer Ruby versions

# String to symbol risk analysis
user_input = "user_input"
sym = user_input.to_sym  # Can lead to memory exhaustion through symbol flooding in older Rubies
sym = user_input.intern   # Alias for to_sym

# Safer alternative in security-sensitive code
ALLOWED_KEYS = [:name, :email, :age]
user_input = "name"
sym = user_input.to_sym if ALLOWED_KEYS.include?(user_input.to_sym)
        

# Implementation details
# - Dynamically sized C array under the hood
# - Amortized O(1) append through over-allocation
# - Copy-on-write optimization in some Ruby implementations

# Performance characteristics by operation
# - Random access by index: O(1)
# - Insertion/deletion at beginning: O(n)
# - Insertion/deletion at end: Amortized O(1)
# - Search for value: O(n)

# Common algorithmic patterns
array = [5, 2, 8, 1, 9]

# Functional operations (non-mutating)
mapped = array.map { |x| x * 2 }        # [10, 4, 16, 2, 18]
filtered = array.select { |x| x > 5 }   # [8, 9]
reduced = array.reduce(0) { |sum, x| sum + x }  # 25

# Destructive operations (mutating)
array.sort!          # [1, 2, 5, 8, 9] - sorts in place
array.map! { |x| x * 2 }  # [2, 4, 10, 16, 18] - transforms in place

# Specialized array operations
flat = [1, [2, [3, 4]]].flatten  # [1, 2, 3, 4]
combos = [1, 2, 3].combination(2).to_a  # [[1, 2], [1, 3], [2, 3]]
transposed = [[1, 2], [3, 4]].transpose  # [[1, 3], [2, 4]]

# Memory optimizations
large_array = Array.new(1000000)  # Pre-allocate for known size
large_array = Array.new(1000000, 0)  # Fill with default value
large_array = Array.new(1000000) { |i| i }  # Initialize with block
        

# Hash implementation details
# - Prior to Ruby 2.0: MRI used separate chaining with linked lists
# - Ruby 2.0+: Open addressing with quadratic probing for DoS protection
# - Ruby preserves insertion order since 1.9

# Performance characteristics
# - Average lookup: O(1)
# - Worst-case lookup: O(n) (with hash collisions)
# - Ordered enumeration: O(n) in insertion order

# Hash functions and equality
class CustomKey
  attr_reader :id
  
  def initialize(id)
    @id = id
  end
  
  def hash
    # Good hash functions minimize collisions
    # and distribute values evenly
    @id.hash
  end
  
  def eql?(other)
    # Ruby uses eql? for hash key comparison
    self.class == other.class && @id == other.id
  end
end

# Default values
counter = Hash.new(0)  # Default value is 0
"hello".each_char { |c| counter[c] += 1 }  # Character frequency count

# Default value as block
fibonacci = Hash.new { |hash, key| 
  hash[key] = key <= 1 ? key : hash[key-1] + hash[key-2] 
}
fibonacci[100]  # Computes 100th Fibonacci number with memoization

# Performance comparison with different key types
require 'benchmark'

Benchmark.bm do |x|
  string_keys = Hash[Array.new(10000) { |i| ["key#{i}", i] }]
  symbol_keys = Hash[Array.new(10000) { |i| [:"key#{i}", i] }]
  
  x.report("String key lookup") {
    1000.times { string_keys["key5000"] }
  }
  
  x.report("Symbol key lookup") {
    1000.times { symbol_keys[:key5000] }
  }
end
# Symbol keys are generally faster due to optimized hash calculation
        

Class Definition and Structure:

class Vehicle
  @@count = 0  # Class variable
  
  def initialize(make, model)
    @make = make    # Instance variables
    @model = model
    @@count += 1
  end
  
  def specs  # Instance method
    "#{@make} #{@model}"
  end
  
  def self.count  # Class method
    @@count
  end
end
        

Singleton Classes and Eigenclasses:

car = Vehicle.new("Honda", "Civic")

# Creating a singleton method on just this object
def car.special_feature
  "Custom sound system"
end

# This doesn't affect other Vehicle instances
truck = Vehicle.new("Ford", "F-150")
puts car.special_feature       # => "Custom sound system"
puts truck.respond_to?(:special_feature)  # => false
        

# Class definition is executable context
class Person
  puts "Inside class definition: #{self}"  # Outputs: Inside class definition: Person
  
  SPECIES = "Human"  # Constant defined within class scope
  
  def self.species_info
    "Members of #{self} are #{SPECIES}"
  end
end

puts Person.species_info  # "Members of Person are Human"
        

Instance Variable Implementation Details:

class Product
  def initialize(name)
    @name = name
    # @price doesn't exist yet
  end
  
  def price=(value)
    @price = value  # Creates @price instance variable when first assigned
  end
  
  def details
    # Instance variables that don't exist return nil
    price_info = @price.nil? ? "unpriced" : "$#{@price}"
    "#{@name}: #{price_info}"
  end
end

product = Product.new("Widget")
puts product.details        # "Widget: unpriced"
puts product.instance_variables  # [:@name]

product.price = 19.99
puts product.details        # "Widget: $19.99"
puts product.instance_variables  # [:@name, :@price]

# Access via reflection
puts product.instance_variable_get(:@name)  # "Widget"
product.instance_variable_set(:@name, "Super Widget")
puts product.instance_variable_get(:@name)  # "Super Widget"
        

Method Dispatch and Binding:

class Device
  def initialize(serial)
    @serial = serial
    @status = "off"
  end
  
  def power_on
    @status = "on"
    self  # Return self for method chaining
  end
  
  def info
    "Device ##{@serial} is #{@status}"
  end
  
  # Methods can be defined dynamically
  ["reset", "calibrate", "diagnose"].each do |action|
    define_method(action) do |*args|
      "Performing #{action} with #{args.join(', ')}"
    end
  end
end

# Method binding and dispatch
device = Device.new("ABC123")
puts device.power_on.info  # "Device #ABC123 is on"
puts device.calibrate(3, "high")  # "Performing calibrate with 3, high"

# Method objects
info_method = device.method(:info)
puts info_method.call  # "Device #ABC123 is on"

# UnboundMethod objects
power_method = Device.instance_method(:power_on)
bound_method = power_method.bind(device)
bound_method.call
        

Access Control Implementation:

class BankAccount
  attr_reader :balance  # Creates a getter method
  
  def initialize(owner, initial_deposit)
    @owner = owner
    @balance = initial_deposit
    @account_number = generate_number
  end
  
  # Custom setter with validation
  def balance=(new_amount)
    raise ArgumentError, "Balance cannot be negative" if new_amount < 0
    @balance = new_amount
  end
  
  # Custom getter with formatting
  def owner
    @owner.upcase
  end
  
  private
  
  def generate_number
    # Private method
    "ACCT-#{rand(10000..99999)}"
  end
end

# Using instance_eval to access private variables (metaprogramming technique)
account = BankAccount.new("John Smith", 1000)
puts account.instance_eval { @account_number }  # Directly access private instance variable
        

Advanced Example - Demonstrating Ownership and Borrowing:

fn main() {
    // Ownership example
    let s1 = String::from("hello");  // s1 owns this String
    let s2 = s1;                     // ownership moves to s2, s1 is no longer valid
    
    // This would cause a compile error:
    // println!("{}", s1);           // error: value borrowed after move
    
    // Borrowing example
    let s3 = String::from("world");
    let len = calculate_length(&s3); // borrows s3 immutably
    println!("The length of '{}' is {}.", s3, len); // s3 still valid here
    
    let mut s4 = String::from("hello");
    change(&mut s4);                 // borrows s4 mutably
    println!("Modified string: {}", s4);
}

fn calculate_length(s: &String) -> usize {
    s.len()  // returns length without taking ownership
}

fn change(s: &mut String) {
    s.push_str(", world");  // modifies the borrowed string
}
        

// Expression-based syntax allows this:
let y = {
    let x = 3;
    x * x  // Note: no semicolon, returns value
};  // y == 9

// Conditional assignment
let status = if connected { "Connected" } else { "Disconnected" };

// Expression-oriented error handling
let result = match operation() {
    Ok(value) => value,
    Err(e) => return Err(e),
};
        

// Type syntax examples
fn process<T: Display + 'static>(value: &mut T, reference: &'a str) -> Result<Vec<T>, Error>
    where T: Serialize
{
    // Implementation
}

// Struct with lifetime parameter
struct Excerpt<'a> {
    part: &'a str,
}
        

// Advanced pattern matching
match value {
    Person { name: "Alice", age: 20..=30 } => println!("Alice in her 20s"),
    Person { name, age } if age > 60 => println!("{} is a senior", name),
    Point { x: 0, y } => println!("On y-axis at {}", y),
    Some(x @ 1..=5) => println!("Got a small positive number: {}", x),
    _ => println!("No match"),
}
        

fn process(data: &mut Vec<i32>) {
    // Compiler knows:
    // 1. We have exclusive access to modify data
    // 2. We don't own data (it's borrowed)
    // 3. We can't store references to elements beyond function scope
}

fn store<'a>(cache: &mut HashMap<String, &'a str>, value: &'a str) {
    // Compiler enforces:
    // 1. value must live at least as long as 'a
    // 2. cache entries can't outlive their 'a lifetime
}
        

// Declarative macro
macro_rules! vec {
    ( $( $x:expr ),* ) => {
        {
            let mut temp_vec = Vec::new();
            $(
                temp_vec.push($x);
            )*
            temp_vec
        }
    };
}

// Usage
let v = vec![1, 2, 3];  // The ! indicates a macro invocation
        

Memory Layout and Type Implementation:

fn main() {
    // Type sizes and alignment
    println!("i8: size={}, align={}", std::mem::size_of::(), std::mem::align_of::());
    println!("i32: size={}, align={}", std::mem::size_of::(), std::mem::align_of::());
    println!("f64: size={}, align={}", std::mem::size_of::(), std::mem::align_of::());
    println!("char: size={}, align={}", std::mem::size_of::(), std::mem::align_of::());
    println!("bool: size={}, align={}", std::mem::size_of::(), std::mem::align_of::());
    
    // Range behavior
    let max_i8 = i8::MAX;
    let min_i8 = i8::MIN;
    println!("i8 range: {} to {}", min_i8, max_i8);
    
    // Integer overflow behavior (in debug builds)
    // Will panic in debug mode, wrap in release mode
    let mut x: u8 = 255;
    // x += 1; // Would panic in debug mode with "attempt to add with overflow"
    
    // String internals
    let s = String::from("Hello");
    println!("String capacity: {}, len: {}", s.capacity(), s.len());
    
    // Slice references
    let a = [1, 2, 3, 4, 5];
    let slice = &a[1..3]; // Type &[i32]
    println!("Slice: {:?}", slice);
}
        

// Different bases
let decimal = 98_222;      // Decimal with visual separator
let hex = 0xff;            // Hexadecimal
let octal = 0o77;          // Octal
let binary = 0b1111_0000;  // Binary with separator
let byte = b'A';           // Byte (u8 only)

// With explicit types
let explicit_u16: u16 = 5_000;
let with_suffix = 42u8;    // Type suffix

// Integer overflow handling
fn check_overflow() {
    let x: u8 = 255;
    // Different behavior in debug vs release:
    // - Debug: panics with "attempt to add with overflow"
    // - Release: wraps to 0 (defined two's complement behavior)
    // x += 1; 
}
        

// Floating-point literals and operations
let float_with_suffix = 2.0f32;             // With type suffix
let double = 3.14159265359;                 // Default f64
let scientific = 1.23e4;                    // Scientific notation = 12300.0
let irrational = std::f64::consts::PI;      // Constants from standard library

// Special values
let infinity = f64::INFINITY;
let neg_infinity = f64::NEG_INFINITY;
let not_a_number = f64::NAN;

// NaN behavior
assert!(not_a_number != not_a_number);      // NaN is not equal to itself
        

// Size = 1 byte
assert_eq!(std::mem::size_of::(), 1);

// Boolean operations
let a = true;
let b = false;
let conjunction = a && b;        // Logical AND (false)
let disjunction = a || b;        // Logical OR (true)
let negation = !a;               // Logical NOT (false)

// Short-circuit evaluation
let x = false && expensive_function();  // expensive_function is never called
        

// All chars are 4 bytes (to fit any Unicode code point)
assert_eq!(std::mem::size_of::(), 4);

// Character examples
let letter = 'A';       // ASCII character
let emoji = '😊';       // Emoji (single Unicode scalar value)
let kanji = '漢';       // CJK character
let escape = '\n';      // Newline escape sequence

// Unicode code point accessing
let code_point = letter as u32;
let from_code_point = std::char::from_u32(0x2764).unwrap(); // ❤
        

// String literal (str slice) - static lifetime, immutable reference
let string_literal: &str = "Hello";

// String object - owned, heap-allocated, growable
let mut owned_string = String::from("Hello");
owned_string.push_str(", world!");

// Memory layout of String (3-word struct):
// - Pointer to heap buffer
// - Capacity (how much memory is reserved)
// - Length (how many bytes are used)
let s = String::from("Hello");
println!("Capacity: {}, Length: {}", s.capacity(), s.len());

// Safe UTF-8 handling
// "नमस्ते" length: 18 bytes, 6 chars
let hindi = "नमस्ते";
assert_eq!(hindi.len(), 18);           // Bytes
assert_eq!(hindi.chars().count(), 6);  // Characters

// Slicing must occur at valid UTF-8 boundaries
// let invalid_slice = &hindi[0..2]; // Will panic if not a char boundary
let safe_slice = &hindi[0..6];      // First 2 chars (6 bytes)
        

// Type annotation is [T; N] where T is element type and N is length
let array: [i32; 5] = [1, 2, 3, 4, 5];

// Arrays are stack-allocated and have a fixed size known at compile time
// Size = size of element * number of elements
assert_eq!(std::mem::size_of::<[i32; 5]>(), 20); // 4 bytes * 5 elements

// Initialization patterns
let zeros = [0; 10];                 // [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
let one_to_five = core::array::from_fn(|i| i + 1); // [1, 2, 3, 4, 5]

// Arrays implement traits like Copy if their elements do
let copy = array;      // Creates a copy, not a move
assert_eq!(array, copy);

// Bounds checking at runtime (vectors have similar checks)
// let out_of_bounds = array[10]; // Panic: index out of bounds
        

// A tuple with multiple types
let tuple: (i32, f64, bool) = (42, 3.14, true);

// Memory layout: elements are stored sequentially with alignment padding
// (The exact layout depends on the target architecture)
struct TupleRepresentation {
    first: i32,    // 4 bytes
    // 4 bytes padding to align f64 on 8-byte boundary
    second: f64,   // 8 bytes
    third: bool    // 1 byte
    // 7 bytes padding to make the whole struct aligned to 8 bytes
}

// Accessing elements
let first = tuple.0;
let second = tuple.1;

// Destructuring
let (x, y, z) = tuple;
assert_eq!(x, 42);

// Unit tuple: carries no information but is useful in generic contexts
let unit: () = ();

// Pattern matching with tuple
match tuple {
    (42, _, true) => println!("Match found"),
    _ => println!("No match"),
}
        

if/else as an Expression:

let result = if some_condition {
    compute_value()  // Returns some type T
} else if other_condition {
    alternative_value()  // Must also return type T
} else {
    default_value()  // Must also return type T
};  // Note: semicolon is required here as this is a statement
        

Advanced match Example:

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

fn process_message(msg: Message) {
    match msg {
        Message::Quit => println!("Quitting"),
        Message::Move { x, y } => println!("Moving to ({}, {})", x, y),
        Message::Write(text) if text.len() > 0 => println!("Text message: {}", text),
        Message::Write(_) => println!("Empty text message"),
        Message::ChangeColor(r, g, b) => {
            println!("Change color to rgb({}, {}, {})", r, g, b);
        }
    }
}
        

Loops as Expressions:

// loop with a return value
let result = loop {
    // Some computation
    if condition {
        break computed_value;  // Returns from the loop
    }
};

// Labeled loops for breaking/continuing outer loops
'outer: for x in 0..10 {
    'inner: for y in 0..10 {
        if condition(x, y) {
            break 'outer;  // Breaks the outer loop
        }
    }
}
        

Error Propagation with ?:

fn read_file_contents(path: &str) -> Result {
    use std::fs::File;
    use std::io::Read;
    
    let mut file = File::open(path)?;  // Returns error if file can't be opened
    let mut contents = String::new();
    file.read_to_string(&mut contents)?;  // Returns error if reading fails
    Ok(contents)  // Return success with the contents
}
        

If/Else Expression Characteristics:

// Conditional must be a boolean (no implicit conversions)
let x = 5;
if x { // Error: expected `bool`, found integer
    println!("This won't compile");
}

// Using if in a let statement
let y = 10;
let result = if y > 5 {
    // Each branch must return values of compatible types
    "greater"
} else {
    "less or equal"
    // The following would cause a compile error:
    // 42  // Type mismatch: expected &str, found integer
};

// If without else returns () in the else branch
let z = if y > 20 { "large" }; // Type is Option<_> due to possible missing value
        

Advanced Match Patterns:

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

fn handle_message(msg: Message) -> String {
    match msg {
        // Pattern matching with destructuring
        Message::Move { x, y } => format!("Moving to position ({}, {})", x, y),
        
        // Pattern with guard condition
        Message::Write(text) if text.len() > 100 => format!("Long message: {}...", &text[0..10]),
        Message::Write(text) => format!("Message: {}", text),
        
        // Multiple patterns
        Message::Quit | Message::ChangeColor(_, _, _) => String::from("Operation not supported"),
        
        // Match can be exhaustive without _ when all variants are covered
    }
}

// Pattern matching with references and bindings
fn inspect_reference(value: &Option<String>) {
    match value {
        Some(s) if s.starts_with("Hello") => println!("Greeting message"),
        Some(s) => println!("String: {}", s),
        None => println!("No string"),
    }
}

// Match with ranges and binding
fn parse_digit(c: char) -> Option<u32> {
    match c {
        '0'..='9' => Some(c.to_digit(10).unwrap()),
        _ => None,
    }
}
        

Loop Expression Semantics:

// 1. Infinite loop with value
fn find_first_multiple_of_7(limit: u32) -> Option<u32> {
    let mut counter = 1;
    
    let result = loop {
        if counter > limit {
            break None;
        }
        
        if counter % 7 == 0 {
            break Some(counter);
        }
        
        counter += 1;
    };
    
    result
}

// 2. Labeled loops for complex control flow
fn search_2d_grid(grid: &Vec<Vec<i32>>, target: i32) -> Option<(usize, usize)> {
    'outer: for (i, row) in grid.iter().enumerate() {
        'inner: for (j, &value) in row.iter().enumerate() {
            if value == target {
                // Break from both loops at once
                break 'outer Some((i, j));
            }
        }
    }
    
    None // Target not found
}

// 3. Iteration with ownership semantics
fn process_vector() {
    let v = vec![1, 2, 3, 4];
    
    // Borrowing each element
    for x in &v {
        println!("Value: {}", x);
    }
    
    // Mutable borrowing
    let mut v2 = v;
    for x in &mut v2 {
        *x *= 2;
    }
    
    // Taking ownership (consumes the vector)
    for x in v2 {
        println!("Owned value: {}", x);
    }
    // v2 is no longer accessible here
}
        

Error Handling with Early Returns:

use std::fs::File;
use std::io::{self, Read};

// Traditional early returns
fn read_file_verbose(path: &str) -> Result<String, io::Error> {
    let file_result = File::open(path);
    
    let mut file = match file_result {
        Ok(f) => f,
        Err(e) => return Err(e), // Early return on error
    };
    
    let mut content = String::new();
    match file.read_to_string(&mut content) {
        Ok(_) => Ok(content),
        Err(e) => Err(e),
    }
}

// Using the ? operator for propagating errors
fn read_file_concise(path: &str) -> Result<String, io::Error> {
    let mut file = File::open(path)?; // Returns error if file can't be opened
    let mut content = String::new();
    file.read_to_string(&mut content)?; // Returns error if reading fails
    Ok(content)
}

// The ? operator also works with Option
fn first_even_number(numbers: &[i32]) -> Option<i32> {
    let first = numbers.get(0)?; // Early return None if empty
    
    if first % 2 == 0 {
        Some(*first)
    } else {
        None
    }
}
        

Never Type in Control Flow:

fn exit_process() -> ! {
    std::process::exit(1);
}

fn main() {
    let value = if condition() {
        42
    } else {
        exit_process(); // This works because ! can coerce to any type
    };
    
    // Infinite loops technically have return type !
    let result = loop {
        // This loop never breaks, so it has type !
    };
    // Code here is unreachable
}
        

Parameter passing patterns:

// Taking ownership
fn consume(s: String) {
    println!("{}", s);
} // String is dropped here

// Borrowing immutably
fn inspect(s: &String) {
    println!("Length: {}", s.len());
} // Reference goes out of scope, original value unaffected

// Borrowing mutably
fn modify(s: &mut String) {
    s.push_str(" modified");
} // Changes are reflected in the original value
        

Expression vs. Statement distinction:

fn expression_return() -> i32 {
    let x = 5; // Statement (doesn't return a value)
    x + 1      // Expression (returns a value) - this is returned
}

fn statement_return() -> () {
    let x = 5;
    x + 1;     // This is a statement due to the semicolon, returns ()
}
        

FFI Example:

#[no_mangle]
pub extern "C" fn add_from_c(a: i32, b: i32) -> i32 {
    a + b
}
        

Parameter patterns:

// By value (takes ownership)
fn process(data: String) { /* ... */ }

// By reference (borrowing)
fn analyze(data: &String) { /* ... */ }

// By mutable reference
fn update(data: &mut String) { /* ... */ }

// Pattern destructuring in parameters
fn process_point((x, y): (i32, i32)) { /* ... */ }

// With default values (via Option pattern)
fn configure(settings: Option<Settings>) {
    let settings = settings.unwrap_or_default();
    // ...
}
        

Return value examples:

// Returning Result with ? operator for error propagation
fn read_username_from_file() -> Result<String, io::Error> {
    let mut file = File::open("username.txt")?;
    let mut username = String::new();
    file.read_to_string(&mut username)?;
    Ok(username)
}

// Diverging function (never returns normally)
fn exit_process() -> ! {
    println!("Exiting...");
    std::process::exit(1);
}
        

Expression-oriented programming examples:

// Block expressions
let x = {
    let inner = 2;
    inner * inner  // Returns 4
};

// if expressions
let status = if score > 60 { "pass" } else { "fail" };

// match expressions
let description = match color {
    Color::Red => "warm",
    Color::Blue => "cool",
    _ => "other",
};

// Rust doesn't have a ternary operator because if expressions serve that purpose
let max = if a > b { a } else { b };
        

fn fizzbuzz(n: u32) -> String {
    match (n % 3, n % 5) {
        (0, 0) => "FizzBuzz".to_string(),
        (0, _) => "Fizz".to_string(),
        (_, 0) => "Buzz".to_string(),
        _ => n.to_string(),
    }
}

fn count_until_keyword(text: &str, keyword: &str) -> usize {
    let mut count = 0;
    
    // loop expressions can also return values
    let found_index = loop {
        if count >= text.len() {
            break None;
        }
        
        if text[count..].starts_with(keyword) {
            break Some(count);
        }
        
        count += 1;
    };
    
    found_index.unwrap_or(text.len())
}
        

// Implicit return (expression-oriented style)
fn calculate_area(width: f64, height: f64) -> f64 {
    width * height  // The last expression is returned
}

// Explicit return (can be used for early returns)
fn find_element(items: &[i32], target: i32) -> Option<usize> {
    for (index, &item) in items.iter().enumerate() {
        if item == target {
            return Some(index);  // Early return
        }
    }
    None  // Implicit return if no match found
}
        

Analyzing Ownership Moves with Debug Visualization:

fn main() {
    // String is stored on the heap with metadata on the stack
    let s1 = String::from("hello");
    // Stack: s1 (ptr -> heap, capacity: 5, length: 5)
    // Heap: "hello"
    
    let s2 = s1;
    // Stack: s2 (ptr -> heap, capacity: 5, length: 5)
    // s1 is now invalid - its metadata is no longer accessible
    
    // If we had a garbage collector, both s1 and s2 could 
    // point to the same data, creating potential issues
}
        

Ownership and Stack/Heap Mechanics:

fn main() {
    // Stack allocation - Copy trait implementation means values are copied
    let x = 5;
    let y = x;  // x is copied, both x and y are valid
    
    // Heap allocation via String - no Copy trait
    let s1 = String::from("hello");  // s1 owns heap memory
    // Memory layout: s1 (ptr, len=5, capacity=5) -> heap: "hello"
    
    let s2 = s1;  // Move occurs here
    // Memory layout: s2 (ptr, len=5, capacity=5) -> heap: "hello"
    // s1 is invalidated
    
    // drop(s2) runs automatically at end of scope, freeing heap memory
}
        

Advanced Borrowing Patterns:

fn main() {
    let mut data = vec![1, 2, 3];
    
    // Non-lexical lifetimes (NLL) example
    let x = &data[0];  // Immutable borrow starts
    println!("{}", x); // Immutable borrow used
    // Immutable borrow ends here, as it's no longer used
    
    // This works because the immutable borrow's lifetime ends before mutable borrow starts
    data.push(4);      // Mutable borrow for this operation
    
    // Borrowing disjoint parts of a structure
    let mut v = vec![1, 2, 3, 4];
    let (a, b) = v.split_at_mut(2);
    // Now a and b are mutable references to different parts of the same vector
    a[0] = 10;
    b[1] = 20;
    // This is safe because a and b refer to non-overlapping regions
}
        

Interior Mutability Example:

use std::cell::RefCell;

fn main() {
    let data = RefCell::new(vec![1, 2, 3]);
    
    // Create immutable reference to RefCell
    let reference = &data;
    
    // But still modify its contents
    reference.borrow_mut().push(4);
    
    println!("{:?}", reference.borrow()); // Prints [1, 2, 3, 4]
    
    // This would panic - borrowing rules checked at runtime
    // let r1 = reference.borrow_mut();
    // let r2 = reference.borrow_mut(); // Runtime panic: already borrowed
}
        

SQL Raw Statements:

DB::statement('CREATE FULLTEXT INDEX fulltext_index ON articles(title, body)');
        

Complex Alterations with Foreign Key Constraints:

Schema::table('posts', function (Blueprint $table) {
    $table->unsignedBigInteger('user_id');
    
    $table->foreign('user_id')
          ->references('id')
          ->on('users')
          ->onDelete('cascade');
});
        

Custom Migration Repository:

// In a service provider
$this->app->singleton('migration.repository', function ($app) {
    return new CustomMigrationRepository(
        $app['db'], 'migrations'
    );
});
        

// Multiple seeders with specific ordering and conditionals
public function run()
{
    if (app()->environment('local', 'testing')) {
        $this->call([
            PermissionsSeeder::class,
            RolesSeeder::class,
            UsersSeeder::class,
            // Dependencies must be seeded first
            PostsSeeder::class,
            CommentsSeeder::class,
        ]);
    } else {
        $this->call(ProductionMinimalSeeder::class);
    }
}
        

// Advanced factory with states and relationships
class UserFactory extends Factory
{
    protected $model = User::class;
    
    public function definition()
    {
        return [
            'name' => $this->faker->name(),
            'email' => $this->faker->unique()->safeEmail(),
            'email_verified_at' => now(),
            'password' => Hash::make('password'),
            'remember_token' => Str::random(10),
        ];
    }
    
    // State definitions for variations
    public function admin()
    {
        return $this->state(function (array $attributes) {
            return [
                'role' => 'admin',
                'permissions' => json_encode(['manage_users', 'manage_content'])
            ];
        });
    }
    
    // After-creation hooks for relationships or additional processing
    public function configure()
    {
        return $this->afterCreating(function (User $user) {
            $user->profile()->create([
                'bio' => $this->faker->paragraph(),
                'avatar' => 'default.jpg'
            ]);
        });
    }
}
        

// Complex factory usage with relationships
User::factory()
    ->admin()
    ->has(Post::factory()->count(3)->has(
        Comment::factory()->count(5)
    ))
    ->count(10)
    ->create();

// Sequence-based attribute generation
User::factory()
    ->count(5)
    ->sequence(
        ['department' => 'Engineering'],
        ['department' => 'Marketing'],
        ['department' => 'Sales']
    )
    ->create();
        

// Dynamic test data in feature tests
public function test_user_can_view_posts()
{
    $user = User::factory()->create();
    $posts = Post::factory()
        ->count(3)
        ->for($user)
        ->create();
        
    $response = $this->actingAs($user)
                     ->get('dashboard');
                     
    $response->assertOk();
    $posts->each(function ($post) use ($response) {
        $response->assertSee($post->title);
    });
}
        

Idempotent Seeder Pattern for Production:

public function run()
{
    // Avoid duplicates in reference data
    $countries = [
        ['code' => 'US', 'name' => 'United States'],
        ['code' => 'CA', 'name' => 'Canada'],
        // More countries...
    ];
    
    foreach ($countries as $country) {
        Country::updateOrCreate(
            ['code' => $country['code']], // Identify by code
            $country // Full data to insert/update
        );
    }
}
        

// Optimized bulk seeding
public function run()
{
    Model::unguard();
    DB::disableQueryLog();
    
    $totalRecords = 100000;
    $chunkSize = 1000;
    
    DB::transaction(function () use ($totalRecords, $chunkSize) {
        for ($i = 0; $i < $totalRecords; $i += $chunkSize) {
            $users = User::factory()
                ->count($chunkSize)
                ->make()
                ->toArray();
                
            User::withoutEvents(function () use ($users) {
                User::insert($users);
            });
            
            // Free memory
            unset($users);
        }
    });
    
    Model::reguard();
}
        

Relationship Internals Example:

// In Illuminate\Database\Eloquent\Relations\HasMany:

protected function getRelationExistenceQuery(Builder $query, Builder $parentQuery, $columns = ['*'])
{
    return $query->select($columns)->whereColumn(
        $parentQuery->getModel()->qualifyColumn($this->localKey),
        '=',
        $this->getQualifiedForeignKeyName()
    );
}
        

Configuration in auth.php:

return [
    'defaults' => [
        'guard' => 'web',
        'passwords' => 'users',
    ],

    'guards' => [
        'web' => [
            'driver' => 'session',
            'provider' => 'users',
        ],
        'api' => [
            'driver' => 'sanctum',
            'provider' => 'users',
        ],
    ],

    'providers' => [
        'users' => [
            'driver' => 'eloquent',
            'model' => App\Models\User::class,
        ],
    ],
];
        

Manual Authentication Implementation:

public function authenticate(Request $request)
{
    $credentials = $request->validate([
        'email' => ['required', 'email'],
        'password' => ['required'],
    ]);
 
    // Attempt to authenticate with remember cookie
    if (Auth::attempt($credentials, $request->boolean('remember'))) {
        $request->session()->regenerate();
 
        // Access control logic
        return $this->handleUserRedirect(Auth::user());
    }
 
    // Authentication failed
    return back()->withErrors([
        'email' => 'The provided credentials do not match our records.',
    ])->onlyInput('email');
}
        

1. Authentication Guards Customization:

// config/auth.php
'guards' => [
    'web' => [
        'driver' => 'session',
        'provider' => 'users',
    ],
    
    // Custom guard example
    'admin' => [
        'driver' => 'session',
        'provider' => 'admins',
    ],
    
    // Token guard example
    'api' => [
        'driver' => 'sanctum',
        'provider' => 'users',
    ],
],

// Custom provider
'providers' => [
    'users' => [
        'driver' => 'eloquent',
        'model' => App\Models\User::class,
    ],
    
    'admins' => [
        'driver' => 'eloquent',
        'model' => App\Models\Admin::class,
    ],
],
        

2. Custom User Provider Implementation:

namespace App\Extensions;

use Illuminate\Contracts\Auth\UserProvider;
use Illuminate\Contracts\Auth\Authenticatable;

class CustomUserProvider implements UserProvider
{
    public function retrieveById($identifier) {
        // Custom logic to retrieve user by ID
    }
    
    public function retrieveByToken($identifier, $token) {
        // Custom logic for remember me token
    }
    
    public function updateRememberToken(Authenticatable $user, $token) {
        // Update token logic
    }
    
    public function retrieveByCredentials(array $credentials) {
        // Retrieve user by credentials
    }
    
    public function validateCredentials(Authenticatable $user, array $credentials) {
        // Validate credentials
    }
}

// Register in a service provider
Auth::provider('custom-provider', function ($app, array $config) {
    return new CustomUserProvider($config);
});
        

3. Custom Auth Guard Implementation:

namespace App\Extensions;

use Illuminate\Contracts\Auth\Guard;
use Illuminate\Contracts\Auth\UserProvider;
use Illuminate\Contracts\Auth\Authenticatable;

class CustomGuard implements Guard
{
    protected $provider;
    protected $user;

    public function __construct(UserProvider $provider)
    {
        $this->provider = $provider;
    }
    
    public function check() {
        return ! is_null($this->user());
    }
    
    public function guest() {
        return ! $this->check();
    }
    
    public function user() {
        if (! is_null($this->user)) {
            return $this->user;
        }
        
        // Custom logic to retrieve authenticated user
    }
    
    public function id() {
        if ($user = $this->user()) {
            return $user->getAuthIdentifier();
        }
    }
    
    public function validate(array $credentials = []) {
        // Custom validation logic
    }
    
    public function setUser(Authenticatable $user) {
        $this->user = $user;
        return $this;
    }
}

// Register in a service provider
Auth::extend('custom-guard', function ($app, $name, array $config) {
    return new CustomGuard($app->make('auth')->createUserProvider($config['provider']));
});
        

4. Customizing Authentication Middleware:

namespace App\Http\Middleware;

use Closure;
use Illuminate\Auth\Middleware\Authenticate as Middleware;

class CustomAuthenticate extends Middleware
{
    protected function redirectTo($request)
    {
        if ($request->expectsJson()) {
            return response()->json(['message' => 'Unauthorized'], 401);
        }
        
        if ($request->is('admin/*')) {
            return route('admin.login');
        }
        
        return route('login');
    }
    
    public function handle($request, Closure $next, ...$guards)
    {
        // Custom pre-authentication logic
        
        $result = parent::handle($request, $next, ...$guards);
        
        // Custom post-authentication logic
        
        return $result;
    }
}
        

Middleware Structure:

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;
use Symfony\Component\HttpFoundation\Response;

class ExampleMiddleware
{
    public function handle(Request $request, Closure $next): Response
    {
        // Pre-processing logic

        $response = $next($request);

        // Post-processing logic
        
        return $response;
    }
}
        

Pipeline Implementation (simplified):

// Simplified version of how Laravel creates the middleware pipeline
$pipeline = new Pipeline($container);

return $pipeline
    ->send($request)
    ->through($middleware)
    ->then(function ($request) use ($route) {
        return $route->run($request);
    });
        

Implementation Details:

Global middleware is registered in the $middleware property of the app/Http/Kernel.php class:

protected $middleware = [
    // These run in the order listed for every request
    \App\Http\Middleware\TrustProxies::class,
    \Fruitcake\Cors\HandleCors::class,
    \App\Http\Middleware\PreventRequestsDuringMaintenance::class,
    \Illuminate\Foundation\Http\Middleware\ValidatePostSize::class,
    \App\Http\Middleware\TrimStrings::class,
    \Illuminate\Foundation\Http\Middleware\ConvertEmptyStringsToNull::class,
];
        

Behind the scenes, Laravel's HttpKernel sends requests through the global middleware stack using the Pipeline pattern:

// Simplified code from Illuminate\Foundation\Http\Kernel
protected function sendRequestThroughRouter($request)
{
    $this->app->instance('request', $request);
    
    Facade::clearResolvedInstance('request');
    
    $this->bootstrap();
    
    return (new Pipeline($this->app))
                ->send($request)
                ->through($this->app->shouldSkipMiddleware() ? [] : $this->middleware)
                ->then($this->dispatchToRouter());
}
        

Registration and Application:

Route middleware is registered in the $routeMiddleware property of the HTTP Kernel:

protected $routeMiddleware = [
    'auth' => \App\Http\Middleware\Authenticate::class,
    'auth.basic' => \Illuminate\Auth\Middleware\AuthenticateWithBasicAuth::class,
    'cache.headers' => \Illuminate\Http\Middleware\SetCacheHeaders::class,
    'can' => \Illuminate\Auth\Middleware\Authorize::class,
    'guest' => \App\Http\Middleware\RedirectIfAuthenticated::class,
    'password.confirm' => \Illuminate\Auth\Middleware\RequirePassword::class,
    'signed' => \Illuminate\Routing\Middleware\ValidateSignature::class,
    'throttle' => \Illuminate\Routing\Middleware\ThrottleRequests::class,
    'verified' => \Illuminate\Auth\Middleware\EnsureEmailIsVerified::class,
];
        

Application to routes can be done through several methods:

// Single middleware
Route::get('profile', function () {
    // ...
})->middleware('auth');

// Multiple middleware
Route::get('admin/dashboard', function () {
    // ...
})->middleware(['auth', 'role:admin']);

// Middleware with parameters
Route::get('api/resource', function () {
    // ...
})->middleware('throttle:60,1');

// Controller middleware
class UserController extends Controller
{
    public function __construct()
    {
        $this->middleware('auth');
        $this->middleware('log')->only('index');
        $this->middleware('subscribed')->except('store');
    }
}
        

Structure and Configuration:

Middleware groups are defined in the $middlewareGroups property of the HTTP Kernel:

protected $middlewareGroups = [
    'web' => [
        \App\Http\Middleware\EncryptCookies::class,
        \Illuminate\Cookie\Middleware\AddQueuedCookiesToResponse::class,
        \Illuminate\Session\Middleware\StartSession::class,
        \Illuminate\View\Middleware\ShareErrorsFromSession::class,
        \App\Http\Middleware\VerifyCsrfToken::class,
        \Illuminate\Routing\Middleware\SubstituteBindings::class,
    ],

    'api' => [
        'throttle:api',
        \Illuminate\Routing\Middleware\SubstituteBindings::class,
    ],

    // Custom middleware groups can be defined here
    'admin' => [
        'auth',
        'role:admin',
        'log.admin.actions',
    ],
];
        

Application to routes:

// Apply middleware group
Route::middleware('admin')->group(function () {
    Route::get('admin/settings', 'AdminController@settings');
    Route::get('admin/reports', 'AdminController@reports');
});

// Laravel automatically applies middleware groups in RouteServiceProvider
// Inside the boot() method of RouteServiceProvider
Route::middleware('web')
    ->namespace($this->namespace)
    ->group(base_path('routes/web.php'));
        

Middleware Parameters:

Laravel supports parameterized middleware using colon syntax:

// In Kernel.php
protected $routeMiddleware = [
    'role' => \App\Http\Middleware\CheckRole::class,
];

// In middleware
public function handle($request, Closure $next, $role)
{
    if (!$request->user()->hasRole($role)) {
        return redirect('home');
    }
    
    return $next($request);
}

// In route definition
Route::get('admin', function () {
    // ...
})->middleware('role:administrator');

// Multiple parameters
Route::get('admin', function () {
    // ...
})->middleware('role:editor,author');
        

// Different ways to access form data
$name = $request->input('name');
$name = $request->name;
$name = $request->get('name');
$all = $request->all();
$only = $request->only(['name', 'email']);
$except = $request->except(['password']);

// File uploads
$file = $request->file('document');
$hasFile = $request->hasFile('document');
$isValid = $request->file('document')->isValid();
        

Manual Validator Creation:

$validator = Validator::make($request->all(), [
    'email' => 'required|email|unique:users,email,'.$user->id,
    'name' => 'required|string|max:255',
]);

if ($validator->fails()) {
    // Access the validator's MessageBag
    $errors = $validator->errors();
    
    // Manually redirect with errors
    return redirect()->back()
                     ->withErrors($errors)
                     ->withInput();
}
        

// app/Http/Requests/StoreUserRequest.php
class StoreUserRequest extends FormRequest
{
    public function authorize()
    {
        return $this->user()->can('create-users');
    }

    public function rules()
    {
        return [
            'name' => ['required', 'string', 'max:255'],
            'email' => [
                'required', 
                'email', 
                Rule::unique('users')->ignore($this->user)
            ],
            'role_id' => [
                'required', 
                Rule::exists('roles', 'id')->where(function ($query) {
                    $query->where('active', true);
                })
            ],
        ];
    }
    
    public function messages()
    {
        return [
            'email.unique' => 'This email is already registered in our system.'
        ];
    }

    public function attributes()
    {
        return [
            'email' => 'email address',
        ];
    }
    
    // Custom validation preprocessing
    protected function prepareForValidation()
    {
        $this->merge([
            'name' => ucwords(strtolower($this->name)),
        ]);
    }
    
    // After validation hooks
    public function withValidator($validator)
    {
        $validator->after(function ($validator) {
            if ($this->somethingElseIsInvalid()) {
                $validator->errors()->add('field', 'Something is wrong with this field!');
            }
        });
    }
}

// Usage in controller
public function store(StoreUserRequest $request)
{
    // Validation already occurred
    $validated = $request->validated();
    // or
    $safe = $request->safe()->only(['name', 'email']);
    
    User::create($validated);
    
    return redirect()->route('users.index');
}
        

// Using validation rule objects
$rules = [
    'payment_method' => 'required',
    'card_number' => [
        Rule::requiredIf(fn() => $request->payment_method === 'credit_card'),
        'nullable',
        'string',
        new CreditCardRule
    ]
];

// Using the 'sometimes' rule
$validator = Validator::make($request->all(), [
    'address' => 'sometimes|required|string|max:255',
]);

// Conditionally adding rules
$validator = Validator::make($request->all(), $rules);

if ($request->has('subscription')) {
    $validator->sometimes('plan_id', 'required|exists:plans,id', function ($input) {
        return $input->subscription === true;
    });
}
        

Custom Error Formatting:

// Customize error format for API responses
use Illuminate\Contracts\Validation\Validator;
use Illuminate\Http\Exceptions\HttpResponseException;

protected function failedValidation(Validator $validator)
{
    throw new HttpResponseException(response()->json([
        'success' => false,
        'errors' => $validator->errors(),
        'message' => 'Validation errors'
    ], 422));
}
        

Rule Declaration Patterns:

// Multiple approaches to defining rules
$rules = [
    // String-based rules
    'email' => 'required|email|unique:users,email,'.auth()->id(),
    
    // Array-based rules
    'password' => [
        'required',
        'string',
        'min:8',
        'confirmed',
        Rule::notIn($commonPasswords)
    ],
    
    // Conditional rules using Rule class
    'profile_image' => [
        Rule::requiredIf(fn() => $request->has('is_public_profile')),
        'image',
        'max:2048'
    ],
    
    // Using when() method
    'company_name' => Rule::when($request->type === 'business', [
        'required',
        'string',
        'max:100',
    ], ['nullable']),
    
    // Complex validation with dependencies between fields
    'expiration_date' => [
        Rule::requiredIf(fn() => $request->payment_type === 'credit_card'),
        'date',
        'after:today'
    ],
    
    // Array validation
    'products' => 'required|array|min:1',
    'products.*.name' => 'required|string|max:255',
    'products.*.price' => 'required|numeric|min:0.01',
    
    // Regular expression validation
    'slug' => [
        'required',
        'alpha_dash',
        'regex:/^[a-z0-9-]+$/'
    ]
];
        

1. Custom Rule Objects:

// app/Rules/ValidRecaptcha.php
class ValidRecaptcha implements Rule
{
    protected $ip;
    
    public function __construct()
    {
        $this->ip = request()->ip();
    }
    
    public function passes($attribute, $value)
    {
        $response = Http::asForm()->post('https://www.google.com/recaptcha/api/siteverify', [
            'secret' => config('services.recaptcha.secret'),
            'response' => $value,
            'remoteip' => $this->ip
        ]);
        
        return $response->json('success') === true &&
               $response->json('score') >= 0.5;
    }
    
    public function message()
    {
        return 'The :attribute verification failed. Please try again.';
    }
}

// Usage
$rules = [
    'g-recaptcha-response' => ['required', new ValidRecaptcha],
];
        

2. Validator Extension (Global):

// In a service provider's boot method
Validator::extend('unique_translation', function ($attribute, $value, $parameters, $validator) {
    [$table, $column, $ignoreId, $locale] = array_pad($parameters, 4, null);
    
    $query = DB::table($table)->where($column->{$locale}, $value);
    
    if ($ignoreId) {
        $query->where('id', '!=', $ignoreId);
    }
    
    return $query->count() === 0;
});

// Custom message in validation.php language file
'unique_translation' => 'The :attribute already exists for this language.',

// Usage
$rules = [
    'title.en' => 'unique_translation:posts,title,'.optional($post)->id.',en',
];
        

3. Implicit Validator Extension:

// In a service provider's boot method
Validator::extendImplicit('required_translation', function ($attribute, $value, $parameters, $validator) {
    // Get the main attribute name (e.g., "title" from "title.en")
    $mainAttribute = explode('.', $attribute)[0];
    $data = $validator->getData();
    
    // Check if at least one translation is provided
    foreach ($data[$mainAttribute] ?? [] as $translationValue) {
        if (!empty($translationValue)) {
            return true;
        }
    }
    
    return false;
});

// Usage
$rules = [
    'title' => 'required_translation',
];
        

1. Form Request with Custom Response:

// app/Http/Requests/UpdateProfileRequest.php
class UpdateProfileRequest extends FormRequest
{
    public function rules()
    {
        return [
            'name' => 'required|string|max:255',
            'email' => 'required|email|unique:users,email,'.auth()->id(),
        ];
    }
    
    // Custom error formatting for API responses
    protected function failedValidation(Validator $validator)
    {
        if (request()->expectsJson()) {
            throw new HttpResponseException(
                response()->json([
                    'success' => false,
                    'errors' => $this->transformErrors($validator),
                    'message' => 'The given data was invalid.'
                ], 422)
            );
        }
        
        parent::failedValidation($validator);
    }
    
    // Transform error format for frontend consumption
    private function transformErrors(Validator $validator)
    {
        $errors = [];
        
        foreach ($validator->errors()->messages() as $key => $value) {
            // Transform dot notation to nested arrays for JavaScript
            $keyParts = explode('.', $key);
            $this->arraySet($errors, $keyParts, $value[0]);
        }
        
        return $errors;
    }
    
    private function arraySet(&$array, $path, $value)
    {
        $key = array_shift($path);
        
        if (empty($path)) {
            $array[$key] = $value;
        } else {
            if (!isset($array[$key]) || !is_array($array[$key])) {
                $array[$key] = [];
            }
            
            $this->arraySet($array[$key], $path, $value);
        }
    }
}
        

2. Contextual Validation Messages:

// app/Http/Requests/RegisterUserRequest.php
class RegisterUserRequest extends FormRequest
{
    public function rules()
    {
        return [
            'email' => 'required|email|unique:users',
            'password' => [
                'required',
                'min:8',
                'regex:/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/',
            ]
        ];
    }
    
    public function messages()
    {
        return [
            'password.regex' => $this->getPasswordStrengthMessage(),
        ];
    }
    
    private function getPasswordStrengthMessage()
    {
        // Check which specific password criterion is failing
        $password = $this->input('password');
        
        if (strlen($password) < 8) {
            return 'Password must be at least 8 characters.';
        }
        
        if (!preg_match('/[a-z]/', $password)) {
            return 'Password must include at least one lowercase letter.';
        }
        
        if (!preg_match('/[A-Z]/', $password)) {
            return 'Password must include at least one uppercase letter.';
        }
        
        if (!preg_match('/\d/', $password)) {
            return 'Password must include at least one number.';
        }
        
        if (!preg_match('/[@$!%*?&]/', $password)) {
            return 'Password must include at least one special character (@$!%*?&).';
        }
        
        return 'Password must be at least 8 characters and include uppercase, lowercase, number and special character.';
    }
}
        

1. After Validation Hooks:

$validator = Validator::make($request->all(), [
    'items' => 'required|array',
    'items.*.id' => 'required|exists:products,id',
    'items.*.quantity' => 'required|integer|min:1',
]);

$validator->after(function ($validator) use ($request) {
    // Business logic validation beyond field rules
    $totalQuantity = collect($request->items)->sum('quantity');
    
    if ($totalQuantity > 100) {
        $validator->errors()->add(
            'items', 
            'You cannot order more than 100 items at once.'
        );
    }
    
    // Check inventory availability
    foreach ($request->items as $index => $item) {
        $product = Product::find($item['id']);
        
        if ($product->stock < $item['quantity']) {
            $validator->errors()->add(
                "items.{$index}.quantity", 
                "Not enough inventory for {$product->name}. Only {$product->stock} available."
            );
        }
    }
});

if ($validator->fails()) {
    return redirect()->back()
                     ->withErrors($validator)
                     ->withInput();
}
        

2. Dependent Validation Using Custom Rules:

// app/Rules/RequiredBasedOnStatus.php
class RequiredBasedOnStatus implements Rule
{
    protected $statusField;
    protected $requiredStatuses;
    
    public function __construct($statusField, $requiredStatuses)
    {
        $this->statusField = $statusField;
        $this->requiredStatuses = is_array($requiredStatuses) 
            ? $requiredStatuses 
            : [$requiredStatuses];
    }
    
    public function passes($attribute, $value, $parameters = [])
    {
        $data = request()->all();
        $status = Arr::get($data, $this->statusField);
        
        // If status requires this field, it must not be empty
        if (in_array($status, $this->requiredStatuses)) {
            return !empty($value);
        }
        
        // Otherwise, field is optional
        return true;
    }
    
    public function message()
    {
        $statuses = implode(', ', $this->requiredStatuses);
        return "The :attribute field is required when status is {$statuses}.";
    }
}

// Usage
$rules = [
    'status' => 'required|in:pending,approved,rejected',
    'rejection_reason' => [
        new RequiredBasedOnStatus('status', 'rejected'),
        'nullable',
        'string',
        'max:500'
    ],
    'approval_date' => [
        new RequiredBasedOnStatus('status', 'approved'),
        'nullable',
        'date'
    ]
];
        

Exporting Validation Rules to JavaScript:

// routes/web.php
Route::get('validation-rules/users', function () {
    // Export Laravel validation rules to be used by JS libraries
    $rules = [
        'name' => 'required|string|max:255',
        'email' => 'required|email',
        'password' => 'required|min:8|confirmed',
    ];
    
    // Map Laravel rules to a format your JS validator can use
    $jsRules = collect($rules)->map(function ($ruleset, $field) {
        $parsedRules = [];
        $ruleArray = is_string($ruleset) ? explode('|', $ruleset) : $ruleset;
        
        foreach ($ruleArray as $rule) {
            if (is_string($rule)) {
                $parsedRule = explode(':', $rule);
                $ruleName = $parsedRule[0];
                $params = isset($parsedRule[1]) ? explode('','', $parsedRule[1]) : [];
                
                $parsedRules[$ruleName] = count($params) ? $params : true;
            }
        }
        
        return $parsedRules;
    })->toArray();
    
    return response()->json($jsRules);
});
        

Customizing Exception Handler:

// app/Exceptions/Handler.php
public function render($request, Throwable $exception)
{
    // API specific validation error handling
    if ($exception instanceof ValidationException && $request->expectsJson()) {
        return response()->json([
            'message' => 'The given data was invalid.',
            'errors' => $this->transformValidationErrors($exception),
            'status_code' => 422
        ], 422);
    }
    
    return parent::render($request, $exception);
}

protected function transformValidationErrors(ValidationException $exception)
{
    $errors = $exception->validator->errors()->toArray();
    
    // Transform errors to a more frontend-friendly format
    return collect($errors)->map(function ($messages, $field) {
        return [
            'field' => $field,
            'message' => $messages[0], // First error message
            'all_messages' => $messages // All error messages
        ];
    })->values()->toArray();
}
        

Detailed Example:

class Vehicle
  attr_accessor :speed
  
  def initialize(speed = 0)
    @speed = speed
  end
  
  def accelerate(amount)
    @speed += amount
  end
  
  def brake(amount)
    @speed -= amount
    @speed = 0 if @speed < 0
  end
end

class Car < Vehicle
  attr_accessor :make, :model
  
  def initialize(make, model, speed = 0)
    super(speed)  # Calls Vehicle#initialize
    @make = make
    @model = model
  end
  
  def honk
    "Beep beep!"
  end
  
  # Override with extension
  def accelerate(amount)
    puts "Pressing gas pedal..."
    super  # Calls Vehicle#accelerate
  end
end

# Method lookup demonstration
tesla = Car.new("Tesla", "Model S")
tesla.accelerate(30)  # Calls Car#accelerate, which calls Vehicle#accelerate
tesla.brake(10)       # Calls Vehicle#brake directly
        

Examining the Inheritance Chain:

# Display class hierarchy
Car.ancestors
# => [Car, Vehicle, Object, Kernel, BasicObject]

# Checking method origin
Car.instance_methods(false)  # Methods defined directly in Car
# => [:make, :model, :make=, :model=, :initialize, :honk, :accelerate]

Vehicle.instance_methods(false)  # Methods defined directly in Vehicle
# => [:speed, :speed=, :initialize, :accelerate, :brake]
        

Class Hierarchy Exploration:

class Base
end

class Derived < Base
end

# Examining the inheritance structure
puts Derived.superclass      # Output: Base
puts Base.superclass         # Output: Object
puts Object.superclass       # Output: BasicObject
puts BasicObject.superclass  # Output: nil

# Viewing the complete ancestor chain
p Derived.ancestors  
# Output: [Derived, Base, Object, Kernel, BasicObject]
        

Method Overriding with Runtime Implications:

class Shape
  def area
    raise NotImplementedError, "#{self.class} must implement area"
  end
  
  def to_s
    "A shape with area: #{area}"
  end
end

class Rectangle < Shape
  def initialize(width, height)
    @width = width
    @height = height
  end
  
  # Override the abstract method
  def area
    @width * @height
  end
end

# Polymorphic behavior
shapes = [Rectangle.new(3, 4)]
shapes.each { |shape| puts shape.to_s }  # Output: "A shape with area: 12"

# Method defined in Shape calls overridden implementation in Rectangle
        

Advanced super Usage Patterns:

class Parent
  def initialize(name, options = {})
    @name = name
    @options = options
  end
  
  def greet(prefix = "Hello")
    "#{prefix}, #{@name}"
  end
  
  def process
    puts "Parent processing"
    yield if block_given?
  end
end

class Child < Parent
  def initialize(name, age, options = {})
    # Pass selected arguments to parent
    super(name, options.merge(child_specific: true))
    @age = age
  end
  
  def greet(prefix = "Hi")
    # Extend parent behavior
    result = super
    "#{result} (#{@age} years old)"
  end
  
  def process
    # Forward block to parent
    super do
      puts "Child-specific processing"
    end
    puts "Child processing complete"
  end
end

child = Child.new("Ruby", 30, { verbose: true })
puts child.greet("Hey")
# Output: "Hey, Ruby (30 years old)"

child.process
# Output:
# Parent processing
# Child-specific processing
# Child processing complete
        

Including Modules and super:

module Loggable
  def log_action(action)
    puts "Logging: #{action}"
  end
  
  def perform(action)
    log_action(action)
    puts "Performing #{action}"
  end
end

class Service
  def perform(action)
    puts "Service performing #{action}"
    yield if block_given?
  end
end

class LoggedService < Service
  include Loggable
  
  def perform(action)
    # Calls Loggable#perform, NOT Service#perform
    # Because Loggable appears earlier in the ancestor chain
    super
    puts "LoggedService completed #{action}"
  end
end

# Method lookup path
p LoggedService.ancestors
# Output: [LoggedService, Loggable, Service, Object, Kernel, BasicObject]

LoggedService.new.perform("sync")
# Output:
# Logging: sync
# Performing sync
# LoggedService completed sync
        

1. Include - Instance Level Mixing:

module Loggable
  def log(message)
    puts "[LOG] #{message}"
  end
end

class Service
  include Loggable
  
  def perform
    log("Service performed")  # Method available at instance level
  end
end

Service.new.log("Direct access")  # Works
# Service.log("Class level")      # Raises NoMethodError
        

2. Extend - Class Level Mixing:

module Findable
  def find_by_name(name)
    all.detect { |item| item.name == name }
  end
end

class Product
  extend Findable
  
  def self.all
    @all ||= []
  end
end

# Product.find_by_name("Widget")  # Method available at class level
# Product.new.find_by_name("Widget") # Raises NoMethodError
        

3. Prepend - Instance Level with Method Precedence:

module Instrumentation
  def save
    start_time = Time.now
    result = super  # Calls the original method
    duration = Time.now - start_time
    puts "Save took #{duration} seconds"
    result
  end
end

class Record
  prepend Instrumentation
  
  def save
    # Original implementation
    puts "Saving record..."
    true
  end
end

Record.new.save
# Output:
# Saving record...
# Save took 0.001 seconds
        

Method Lookup Chain Example:

module M1; def foo; "M1#foo"; end; end
module M2; def foo; "M2#foo"; end; end

class C
  include M1
  prepend M2
  
  def foo
    "C#foo"
  end
end

puts C.ancestors.inspect
# Output: [M2, C, M1, Object, Kernel, BasicObject]
puts C.new.foo
# Output: "M2#foo" (prepended module takes precedence)
        

module Searchable
  module ClassMethods
    def search(query)
      # Class-level search implementation
    end
  end
  
  module InstanceMethods
    def matches?(query)
      # Instance-level matching logic
    end
  end
  
  def self.included(base)
    base.extend(ClassMethods)
    base.include(InstanceMethods)
  end
end

class Article
  include Searchable
  # Now has both search class method and matches? instance method
end
        

class MyClass
  include Enumerable
end

MyClass.included_modules  # => [Enumerable, Kernel]
MyClass.ancestors         # => [MyClass, Enumerable, Object, Kernel, BasicObject]
        

Namespace Implementation:

module PaymentProcessing
  GATEWAY_URL = "https://payment.example.com/api/v2"
  
  class CreditCard
    def process(amount)
      # Implementation
    end
  end
  
  module Validators
    class Luhn
      def self.valid?(number)
        # Implementation
      end
    end
  end
  
  # Nested namespace referencing
  def self.validate_card(number)
    Validators::Luhn.valid?(number)
  end
end

# External reference to nested constants
PaymentProcessing::CreditCard.new
PaymentProcessing::Validators::Luhn.valid?("4111111111111111")
PaymentProcessing::GATEWAY_URL
        

Working with Name Resolution:

module Admin
  class User
    def self.find(id)
      # Admin user lookup implementation
    end
  end
  
  class Dashboard
    # Relative constant reference (same namespace)
    def admin_user
      User.find(1)  
    end
    
    # Absolute path with :: prefix (root namespace)
    def regular_user
      ::User.find(1)
    end
  end
end

# Global namespace
class User
  def self.find(id)
    # Regular user lookup implementation
  end
end
        

Implementation Details:

module Trackable
  def track_event(name)
    puts "Tracking: #{name}"
  end
  
  def self.included(base)
    puts "Trackable included in #{base}"
  end
  
  def self.extended(base)
    puts "Trackable extended in #{base}"
  end
end

# Include: adds instance methods
class Order
  include Trackable
  
  def complete
    track_event("order_completed")
  end
end

# Extend: adds class methods
class Product
  extend Trackable
  
  def self.create
    track_event("product_created")
  end
end

# Demonstrate usage
Order.new.track_event("test")  # Works
# Order.track_event("test")    # NoMethodError

# Product.track_event("test")  # Works
# Product.new.track_event("test") # NoMethodError
        

1. Dual-purpose Modules (both class and instance methods):

module Authentication
  # Instance methods
  def authenticate(password)
    # Implementation
  end
  
  # Hook invoked when module is included
  def self.included(base)
    base.extend(ClassMethods)
  end
  
  # Submodule for class methods
  module ClassMethods
    def authenticate_with_token(token)
      # Implementation
    end
  end
end

class User
  include Authentication
  # Now User has instance method #authenticate
  # and class method .authenticate_with_token
end
        

2. Using prepend for Method Overriding:

module Cacheable
  def find_by_id(id)
    puts "Checking cache first"
    cached_result = read_from_cache(id)
    return cached_result if cached_result
    
    # Fall back to original implementation
    result = super
    write_to_cache(id, result)
    result
  end
  
  private
  
  def read_from_cache(id)
    # Implementation
  end
  
  def write_to_cache(id, data)
    # Implementation
  end
end

class Repository
  prepend Cacheable
  
  def find_by_id(id)
    puts "Finding record #{id} in database"
    # Database lookup implementation
  end
end

# When called, the Cacheable#find_by_id executes first
Repository.new.find_by_id(42)
# Output:
# Checking cache first
# Finding record 42 in database
        

class Service
  include Comparable
  extend Enumerable
end

# Examining inheritance structure
p Service.included_modules         # [Comparable, Kernel]
p Service.singleton_class.included_modules  # [Enumerable, ...]

# Adding modules dynamically
module ExtraFeatures; end
Service.include(ExtraFeatures) if ENV["ENABLE_EXTRAS"]

# Testing for module inclusion
p Service.include?(Comparable)  # true
p Service.singleton_class.include?(Enumerable)  # true
        

Block Implementation Details:

def execute_block
  yield if block_given?
end

execute_block { puts "Block executed" }

# Block parameters and variables
x = 10
[1, 2, 3].each do |number|
  puts number + x  # Accesses x from outer scope
end

# Behind the scenes, the Ruby VM converts blocks to a special internal representation

Proc Internal Behavior:

# Creating Procs - multiple ways
proc1 = Proc.new { |x| x * 2 }
proc2 = proc { |x| x * 2 }  # Kernel#proc is a shorthand

# Arity checking is relaxed
p = Proc.new { |a, b| [a, b] }
p.call(1)      # => [1, nil]
p.call(1, 2, 3) # => [1, 2] (extra arguments discarded)

# Return behavior
def proc_return_test
  p = Proc.new { return "Returning from method!" }
  p.call
  puts "This line never executes"
end

proc_return_test  # Returns from the method when Proc executes

Lambda Internal Behavior:

# Creating lambdas
lambda1 = lambda { |x| x * 2 }
lambda2 = ->(x) { x * 2 }  # Stabby lambda syntax

# Strict arity checking
l = ->(a, b) { [a, b] }
# l.call(1)     # ArgumentError: wrong number of arguments (given 1, expected 2)
# l.call(1,2,3) # ArgumentError: wrong number of arguments (given 3, expected 2)

# Return behavior
def lambda_return_test
  l = lambda { return "Returning from lambda only!" }
  result = l.call
  puts "This line WILL execute"
  result
end

lambda_return_test  # The lambda's return only exits the lambda, not the method

Block Implementation Details:

# Method with yield
def with_logging
  puts "Starting operation"
  result = yield if block_given?
  puts "Operation complete"
  result
end

# Method that explicitly captures a block as Proc
def with_explicit_block(&block)
  puts "Block object: #{block.class}"
  block.call if block
end

# Block local variables vs. closure scope
outer = "visible"
[1, 2, 3].each do |num; inner|  # inner is a block-local variable
  inner = "not visible outside"
  puts "#{num}: Can access outer: #{outer}"
end
# puts inner  # NameError: undefined local variable

Proc Technical Details:

# Return semantics - Procs return from the method they're defined in
def proc_return_demo
  puts "Method started"
  my_proc = Proc.new { return "Early return from proc" }
  my_proc.call
  puts "This never executes"
  return "Normal method return"
end

# Parameter handling in Procs
param_proc = Proc.new { |a, b, c| puts "a:#{a}, b:#{b}, c:#{c}" }
param_proc.call(1)            # a:1, b:nil, c:nil
param_proc.call(1, 2, 3, 4)   # a:1, b:2, c:3 (4 is ignored)

# Converting blocks to Procs
def make_counter
  count = 0
  Proc.new { count += 1 }
end

counter = make_counter
puts counter.call  # 1
puts counter.call  # 2 - maintains state between calls

Lambda Technical Details:

# Return semantics - lambda returns control to calling context
def lambda_return_demo
  puts "Method started"
  my_lambda = -> { return "Return from lambda" }
  result = my_lambda.call
  puts "Still executing, lambda returned: #{result}"
  return "Normal method return"
end

# Parameter handling with advanced syntax
required_lambda = ->(a, b = 1, *rest, required_keyword:, optional_keyword: nil) {
  puts "a: #{a}, b: #{b}, rest: #{rest}, " +
       "required_keyword: #{required_keyword}, optional_keyword: #{optional_keyword}"
}

# Currying and partial application
multiply = ->(x, y) { x * y }
double = multiply.curry[2]
puts double.call(5)  # 10

# Method objects vs lambdas
obj = Object.new
def obj.my_method(x); x * 2; end
method_object = obj.method(:my_method)
# method_object is similar to a lambda but bound to the object

# ActiveRecord query builder pattern
User.where(active: true).order(created_at: :desc).limit(5).each do |user|
  # Process users
end

# Resource management pattern
Database.transaction do |tx|
  tx.execute("UPDATE users SET status = 'active'")
  tx.execute("INSERT INTO audit_logs (message) VALUES ('Activated users')")
end

# Configuration blocks
ApplicationConfig.setup do |config|
  config.timeout = 30
  config.retry_count = 3
  config.logger = Logger.new($stdout)
end

# Event system with callbacks
class EventEmitter
  def initialize
    @callbacks = {}
  end
  
  def on(event, &callback)
    @callbacks[event] ||= []
    @callbacks[event] << callback
  end
  
  def emit(event, *args)
    return unless @callbacks[event]
    @callbacks[event].each { |callback| callback.call(*args) }
  end
end

# Memoization pattern
def memoize
  cache = {}
  Proc.new do |*args|
    cache[args] ||= yield(*args)
  end
end

expensive_calculation = memoize { |n| sleep(1); n * n }

# Function composition
compose = ->(*fns) {
  ->(x) { fns.reverse.reduce(x) { |acc, fn| fn.call(acc) } }
}

add_one = ->(x) { x + 1 }
double = ->(x) { x * 2 }
composed = compose.call(double, add_one)
puts composed.call(3)  # (3+1)*2 = 8

# HTTP middleware pattern
class Middleware
  def initialize(app)
    @app = app
  end
  
  def use(middleware)
    @app = middleware.new(@app)
    self
  end
  
  def call(env)
    @app.call(env)
  end
end

# Validation with lambdas
validators = {
  presence: ->(value) { !value.nil? && !value.empty? },
  numeric: ->(value) { value.to_s.match?(/^\d+$/) },
  email: ->(value) { value.to_s.match?(/\A[\w+\-.]+@[a-z\d\-]+(\.[a-z\d\-]+)*\.[a-z]+\z/i) }
}

Full Exception Structure:

begin
  # Code that might raise exceptions
rescue SpecificError => error_variable
  # Handle specific error
rescue AnotherError, YetAnotherError => error_variable
  # Handle multiple error types
rescue => error_variable  # Defaults to StandardError
  # Handle any StandardError
else
  # Executes only if no exceptions were raised
ensure
  # Always executes, regardless of exceptions
end
        

Custom Exception Classes:

# Creating a custom exception hierarchy
class ApplicationError < StandardError; end
class DatabaseError < ApplicationError
  attr_reader :query

  def initialize(message = "A database error occurred", query = nil)
    @query = query
    super(message)
  end
end

# Usage
begin
  # Database operation
  raise DatabaseError.new("Connection failed", "SELECT * FROM users")
rescue DatabaseError => e
  puts "Error: #{e.message}, Query: #{e.query}"
end
        

def process_data
  begin
    # Process data
  rescue StandardError => e
    logger.error("Error during processing: #{e.message}")
    raise # Re-raises the current exception
  end
end

# Or with transformation
begin
  # Some operation
rescue ArgumentError => e
  # Wrap in a different exception type with context
  raise CustomError.new("Invalid input: #{e.message}").tap { |ex| ex.set_backtrace(e.backtrace) }
end
        

begin
  # Protected code block that might raise exceptions
rescue ExceptionType1 => e
  # Handler for ExceptionType1
rescue ExceptionType2, ExceptionType3 => e
  # Handler for multiple exception types
rescue => e  # Shorthand for `rescue StandardError => e`
  # Fallback handler for any StandardError
else
  # Executes only if no exceptions were raised in the begin block
ensure
  # Always executes after begin, rescue and else clauses
  # Runs regardless of whether an exception occurred
end
        

begin
  # Code that might raise exceptions
rescue => e
  # Standard exception introspection methods
  puts e.message       # String description of the error
  puts e.class         # The exception class
  puts e.backtrace     # Array of strings showing the call stack
  puts e.cause         # The exception that caused this one (Ruby 2.1+)
  
  # Capturing the complete context
  e.instance_variables.each do |var|
    puts "#{var}: #{e.instance_variable_get(var)}"
  end
end
        

# Method definitions have implicit begin
def process_file(path)
  # Method body is implicitly wrapped in a begin block
rescue Errno::ENOENT
  # Handle file not found
end

# Class/module definitions, loops, etc. also have implicit begin
class MyClass
  # Class body has implicit begin
rescue => e
  # Handle exceptions during class definition
end
        

# Basic raise forms
raise                     # Raises RuntimeError with no message
raise "Error message"     # Raises RuntimeError with message
raise ArgumentError       # Raises an ArgumentError with no message
raise ArgumentError.new("Invalid argument") # Raises with message

# Creating and raising in one step
raise ArgumentError, "Invalid argument", caller # With custom backtrace
raise ArgumentError, "Invalid argument", caller[2..-1] # Partial backtrace
        

# Base application exception
class ApplicationError < StandardError; end

# Domain-specific exception categories
class ValidationError < ApplicationError; end
class AuthorizationError < ApplicationError; end
class ResourceError < ApplicationError; end

# Specific exception types
class ResourceNotFoundError < ResourceError
  attr_reader :resource_type, :identifier

  def initialize(resource_type, identifier, message = nil)
    @resource_type = resource_type
    @identifier = identifier
    super(message || "#{resource_type} not found with identifier: #{identifier}")
  end
end

# Usage
begin
  user = User.find(id) || raise(ResourceNotFoundError.new("User", id))
rescue ResourceNotFoundError => e
  logger.error("Resource access failure: #{e.message}")
  redirect_to_error_page(resource_type: e.resource_type)
end
        

# Converting third-party exceptions to application-specific ones
def fetch_data
  begin
    external_api.request(params)
  rescue ExternalAPI::ConnectionError => e
    raise NetworkError.new("API connection failed").tap do |error|
      error.original_exception = e  # Store original for debugging
      error.set_backtrace(e.backtrace)  # Preserve original backtrace
    end
  end
end
        

def fetch_with_retry(max_attempts = 3)
  attempts = 0
  begin
    attempts += 1
    response = api.fetch
  rescue ApiError => e
    if attempts < max_attempts
      sleep(attempts * 2)  # Exponential backoff
      retry
    else
      raise
    end
  end
end
        

class CircuitBreaker
  def initialize(threshold = 5, timeout = 60)
    @failure_count = 0
    @threshold = threshold
    @timeout = timeout
    @state = :closed  # :closed, :open, :half_open
    @last_failure_time = nil
  end

  def execute
    check_state
    
    begin
      result = yield
      success
      result
    rescue => e
      failure(e)
    end
  end

  private
  
  def check_state
    case @state
    when :open
      if Time.now - @last_failure_time > @timeout
        @state = :half_open
      else
        raise CircuitOpenError, "Circuit breaker is open"
      end
    when :half_open, :closed
      # Allow execution
    end
  end

  def success
    @failure_count = 0
    @state = :closed if @state == :half_open
  end

  def failure(exception)
    @failure_count += 1
    @last_failure_time = Time.now
    
    if @state == :half_open || @failure_count >= @threshold
      @state = :open
    end
    
    raise exception
  end
end

# Usage
breaker = CircuitBreaker.new
breaker.execute { api.fetch_data }
        

Bundler's Dependency Resolution Process:

1. Parses the Gemfile to extract gem requirements
2. Builds a dependency graph of all gems and their dependencies
3. Uses a backtracking algorithm to find a set of gem versions that satisfy all constraints
4. Resolves the dependency graph to a concrete set of gems and versions
5. Documents the resolved dependencies in Gemfile.lock
6. Installs the gems in the specified environments (development, test, production)

Gemfile with Advanced Features:

source 'https://rubygems.org'
ruby '3.1.2'

# Core gems
gem 'rails', '~> 7.0.4'
gem 'pg', '~> 1.4.3'
gem 'puma', '~> 5.6.5'

# Environment-specific gems
group :development, :test do
  gem 'rspec-rails', '~> 6.0.0'
  gem 'factory_bot_rails', '~> 6.2.0'
  gem 'debug', platforms: [:mri, :mingw, :x64_mingw]
end

group :production do
  gem 'rack-timeout', '~> 0.6.3'
  gem 'newrelic_rpm', '~> 8.12.0'
end

# Platform-specific gems
platforms :ruby do
  gem 'unicorn'
end

# Git source example
gem 'rails_admin', git: 'https://github.com/rails/rails_admin.git', branch: 'main'

# Path source example (for local development)
gem 'my_custom_gem', path: '../my_custom_gem'

Bundler Runtime Implementation:

# How Bundler is typically initialized in a Rails app
require 'bundler/setup'      # Set up load paths for all gems in Gemfile
Bundler.require(:default)      # Require all default gems
Bundler.require(Rails.env)     # Require environment-specific gems

Gemfile Directive Types:

# Source directives
source 'https://rubygems.org'                     # Primary gem source
source 'https://enterprise.gem-server.com' do     # Scoped source
  gem 'private-enterprise-gem'
end

# Ruby version constraint
ruby '3.1.2', patchlevel: '224'                 # Specific Ruby version requirement

# Basic gem specifications with version constraints
gem 'rails', '~> 7.0.4'                         # Pessimistic version constraint (~>)
gem 'pg', '>= 1.4.0', '< 2.0'                 # Multiple version constraints
gem 'redis', '4.8.0'                            # Exact version

# Gem with options
gem 'nokogiri', '~> 1.13.9',
    require: false,                               # Don't auto-require
    platforms: [:ruby, :mingw, :x64_mingw]        # Platform-specific

# Alternative sources
gem 'rails_admin', 
    git: 'https://github.com/rails/rails_admin.git',  # Git source
    branch: 'main',                                   # Git branch
    ref: 'a204e96'                                    # Git reference

gem 'local_gem', path: '../local_gem'              # Local path source

# Environment-specific gems
group :development do
  gem 'web-console'
  gem 'rack-mini-profiler'
end

group :test do
  gem 'capybara'
  gem 'selenium-webdriver'
end

# Multiple environments
group :development, :test do
  gem 'rspec-rails'
  gem 'factory_bot_rails'
  gem 'debug'
end

# Conditional gems
install_if -> { RUBY_PLATFORM =~ /darwin/ } do     # Install only on macOS
  gem 'terminal-notifier'
end

# Platform-specific gems
platforms :jruby do
  gem 'activerecord-jdbcpostgresql-adapter'
end

Gemfile.lock Structure (Excerpt):

GEM
  remote: https://rubygems.org/
  specs:
    actioncable (7.0.4)
      actionpack (= 7.0.4)
      activesupport (= 7.0.4)
      nio4r (~> 2.0)
      websocket-driver (>= 0.6.1)
    actionmailbox (7.0.4)
      actionpack (= 7.0.4)
      activejob (= 7.0.4)
      activerecord (= 7.0.4)
      activestorage (= 7.0.4)
      activesupport (= 7.0.4)
      mail (>= 2.7.1)
      net-imap
      net-pop
      net-smtp

GIT
  remote: https://github.com/rails/rails_admin.git
  revision: a204e96c221228fcd537e2a59141909796d384b5
  branch: main
  specs:
    rails_admin (3.1.0)
      activemodel-serializers-xml (>= 1.0)
      kaminari (>= 0.14, < 2.0)
      nested_form (~> 0.3)
      rails (>= 6.0, < 8)
      turbo-rails (~> 1.0)

PLATFORMS
  arm64-darwin-21
  x86_64-linux

DEPENDENCIES
  bootsnap
  debug
  jbuilder
  puma (~> 5.0)
  rails (~> 7.0.4)
  rails_admin!
  rspec-rails
  sqlite3 (~> 1.4)
  turbo-rails

RUBY VERSION
   ruby 3.1.2p224

BUNDLED WITH
   2.3.22

Core RubyGems Commands:

• gem install [gemname] -v [version] - Installs a specific gem version
• gem uninstall [gemname] --all - Removes all versions of a gem
• gem pristine [gemname] - Restores gem to original condition
• gem cleanup - Removes old versions of gems
• gem query --remote --name-matches [pattern] - Searches for gems matching pattern
• gem server - Starts a local RDoc server for installed gems
• gem build [gemspec] - Builds a gem from a gemspec
• gem push [gemfile] - Publishes a gem to RubyGems.org
• gem yank [gemname] -v [version] - Removes a published gem version

Advanced Bundler Commands:

• bundle install --deployment - Installs for production with strict Gemfile.lock checking
• bundle install --jobs=4 - Parallel gem installation
• bundle update --conservative [gemname] - Updates a gem with minimal changes
• bundle check - Verifies if dependencies are satisfied
• bundle lock --update - Updates lockfile without installing
• bundle outdated - Shows gems with newer versions available
• bundle viz - Generates a visual dependency graph
• bundle config set --local path 'vendor/bundle' - Sets bundle install path
• bundle package - Packages gems into vendor/cache
• bundle exec --keep-file-descriptors [command] - Runs with gem environment with preserved file handles
• bundle binstubs [gemname] - Creates executable stubs for gem commands
• bundle open [gemname] - Opens gem source in editor

1. Named-field structs:

struct Rectangle {
    width: u32,
    height: u32,
}
        

2. Tuple structs:

struct Point(i32, i32);  // Fields accessed via .0, .1, etc.
        

3. Unit structs:

struct UnitStruct;  // No fields, zero size at runtime
        

enum Result<T, E> {
    Ok(T),    // Success variant containing a value of type T
    Err(E),   // Error variant containing a value of type E
}
        

Memory Layout Example:

enum Message {
    Quit,                       // Just the discriminant
    Move { x: i32, y: i32 },    // Discriminant + two i32 values
    Write(String),              // Discriminant + String (pointer, length, capacity)
    ChangeColor(i32, i32, i32)  // Discriminant + three i32 values
}
        

For this enum, Rust allocates enough space for the largest variant (likely ChangeColor or Write) plus the discriminant.

Type-State Pattern with Enums:

enum Connection {
    Disconnected,
    Connecting { attempt: u32 },
    Connected(TcpStream),
}
        

This pattern guarantees at compile time that operations are only performed on connections in the appropriate state.

Recursive Data Structures:

enum List<T> {
    Cons(T, Box<List<T>>),
    Nil,
}
        

Note the use of Box to break the infinite size recursion.