Traits

Traits are a mechanism for code reuse in single inheritance languages like PHP. PHP classes can only inherit from a single parent class, which sometimes limits the ability to reuse specific sets of methods across different, unrelated class hierarchies. Traits address this by allowing you to define a group of methods that can be injected into multiple classes.

Purpose:
- Code Reusability: Traits enable developers to reuse common functionality across different classes that might not share a direct inheritance relationship.
- Overcoming Single Inheritance Limitations: They provide a way to include behaviors from multiple sources into a single class, effectively mimicking some aspects of multiple inheritance (specifically, multiple inheritance of behavior) without the complexities associated with it.
- Reducing Code Duplication: Instead of copy-pasting code or creating deep, complex inheritance trees, traits offer a clean way to share implementations.

How They Work:
1. Definition: A trait is declared using the `trait` keyword, similar to a class or interface.
```php
trait MyTrait {
public function doSomething() {
// ...
}
}
```
2. Usage: To use a trait within a class, you use the `use` keyword inside the class definition, followed by the trait's name.
```php
class MyClass {
use MyTrait;

public function anotherMethod() {
$this->doSomething(); // Method from MyTrait is available
}
}
```
3. Method Injection: When a class uses a trait, the trait's methods are 'copied' into the class. From the perspective of the consuming class, methods introduced by a trait are indistinguishable from methods defined directly in the class itself.

Conflict Resolution:
PHP provides mechanisms to resolve name conflicts that can arise when:
- A class uses multiple traits that define methods with the same name.
- A trait defines a method with the same name as a method already present in the consuming class.

In case of conflicts between trait methods, the `insteadof` operator can be used to explicitly choose which trait's method to use. The `as` operator can be used to alias a method (give it a new name) or change its visibility.

Benefits:
- Flexibility: Promotes a more modular and flexible design.
- Reduced Boilerplate: Less code to write for common functionalities.
- Clearer Structure: Helps organize code into reusable components without forcing a rigid inheritance hierarchy.

<?php

// Define a trait for logging functionality
trait Logger
{
    public function log(string $message):
    {
        $timestamp = date('Y-m-d H:i:s');
        echo "[{$timestamp}] LOG: {$message}\n";
    }
}

// Define a trait for sending notifications
trait Notifier
{
    public function notify(string $recipient, string $subject, string $body):
    {
        echo "Sending notification to {$recipient} - Subject: '{$subject}'\n";
        echo "Body: '{$body}'\n";
    }
}

// Define a trait that might conflict with a class method for demonstration
trait UniqueIdGenerator
{
    public function generateId(): string
    {
        return uniqid('id_');
    }
}

// Define a class that uses multiple traits
class UserService
{
    use Logger, Notifier, UniqueIdGenerator;

    private string $serviceName = 'UserService';

    public function createUser(string $username, string $email):
    {
        $this->log("Attempting to create user: {$username}");
        $userId = $this->generateId(); // Method from UniqueIdGenerator trait

        // Simulate user creation logic
        echo "User {$username} (ID: {$userId}) with email {$email} created successfully.\n";
        $this->log("User {$username} created. ID: {$userId}");

        // Send a notification to admin
        $this->notify(
            'admin@example.com',
            'New User Registered',
            "A new user '{$username}' with ID '{$userId}' has registered."
        );
    }

    // If a method with the same name exists in the class, it takes precedence over the trait's method.
    // However, in this example, 'generateId' is unique to the trait.
    // If we had a method named `log` here, it would override the trait's `log` method.
    public function getServiceName(): string
    {
        return $this->serviceName;
    }
}

// Another class using just the Logger trait
class ProductService
{
    use Logger;

    public function updateProduct(string $productId, array $data):
    {
        $this->log("Updating product {$productId} with data: " . json_encode($data));
        // ... product update logic ...
        $this->log("Product {$productId} updated successfully.");
    }
}

// --- Usage Examples ---

$userService = new UserService();
$userService->createUser('john.doe', 'john.doe@example.com');
echo "----------------------\n";

$productService = new ProductService();
$productService->updateProduct('PROD-001', ['price' => 29.99, 'stock' => 150]);

?>