Psl Laravel Package

Technical Evaluation

Architecture Fit

PSL (PHP Standard Library) introduces a modern, composable, and type-safe alternative to PHP's native primitives, aligning well with Laravel's evolving architecture. Key fits:

• Async-first design: Leverages fibers (PHP 8.4+) for structured concurrency, complementing Laravel's growing async support (e.g., Swoole, ReactPHP).
• Immutable data structures: Reduces side effects in Laravel's service layer, improving testability and predictability.
• Type safety: Integrates with Laravel's PHP 8.1+ typing, enabling stricter validation (e.g., Type\shape() for request DTOs).
• Functional collections: Replaces ad-hoc array operations with composable methods (e.g., Vec\map() for Eloquent collections).

Misalignment:

• Laravel’s event-driven and queue-based systems (e.g., Illuminate\Queue) may conflict with PSL’s structured concurrency model (e.g., Async\main). Requires careful abstraction.
• Legacy PHP extensions (e.g., PDO, cURL) lack PSL wrappers, necessitating hybrid code paths.

Integration Feasibility

Critical Path:

1. Adopt incrementally: Start with Type and Vec in domain layers.
2. Async migration: Wrap PSL async in Laravel’s Bus or Jobs for compatibility.
3. Hybrid patterns: Use PSL for new features; coexist with legacy code.

Technical Risk

Blockers:

• No Laravel plugins: PSL lacks official integrations (e.g., psl-eloquent).
• Async ecosystem lock-in: PSL’s fibers may conflict with Swoole/ReactPHP in Laravel.

Key Questions

1. Async Strategy:

   • Will we use PSL’s Async or Laravel’s Bus/Jobs for async workflows?
   • How will fibers interact with Laravel’s event loop (e.g., Illuminate\Events)?

2. Type Safety Trade-offs:

   • Should we enforce PSL’s Type system globally, or use it only for DTOs?
   • How will we handle legacy codebases with weak typing?

3. Performance:

   • Are PSL’s immutable collections acceptable for high-throughput APIs?
   • What’s the cost of Vec vs. native arrays in bulk operations?

4. Tooling:

   • Can we configure Psalm/PHPStan to treat PSL types as first-class citizens?
   • Are there plans for Laravel-specific PSL extensions (e.g., psl-eloquent)?

5. Migration Path:

   • Should we rewrite core services (e.g., ServiceProvider) to use PSL, or adopt gradually?
   • How will we handle PSL’s lack of support for Laravel’s Cache, Filesystem, etc.?

Integration Approach

Stack Fit

PSL aligns with Laravel’s modern PHP stack but requires selective adoption:

• Core Fit:
  • Type System: Replace Request validation, FormRequest, and DTOs with Type\shape().
  • Collections: Use Vec/Dict in domain layers (e.g., repository patterns).
  • Async: Pilot in background jobs (e.g., Async\concurrently for batch processing).
• Peripheral Fit:
  • Networking: Avoid PSL’s TCP/HTTP; use Laravel’s HttpClient/Queue.
  • Graph/Tree: Use for niche cases (e.g., ACLs, dependency graphs).

Stack Conflicts:

• Event Loop: PSL’s fibers may clash with Laravel’s Swoole/ReactPHP integrations.
• Legacy Extensions: PSL lacks wrappers for PDO, Redis, etc.; require adapters.

Migration Path

Recommended Order:

1. Type Safety: Replace Request validation with Type\shape().
2. Collections: Adopt Vec/Dict in repositories and services.
3. Async: Pilot in background jobs; avoid mixing with event loop.
4. Tooling: Configure Psalm/PHPStan for PSL types.

Compatibility

Sequencing

1. Isolate PSL Usage:
   • Start in new features or greenfield modules.
   • Avoid mixing PSL and native PHP in the same class.
2. Hybrid Adapters:
   • Create facades to bridge PSL and Laravel (e.g., PslCollection::fromLaravel()).
3. Async Boundaries:
   • Use PSL async only in background jobs, not in HTTP requests.
4. Gradual Replacement:
   • Replace Collection facade with Vec in repositories.
   • Replace Request validation with Type in controllers.

Operational Impact

Maintenance

Key Tasks:

• Document hybrid patterns: Clearly mark where PSL and native PHP coexist.
• Standardize type usage: Enforce Type\shape() for all DTOs.
• Monitor fiber leaks: Ensure async code doesn’t block Laravel’s event loop.

Support