Download the PHP package dbrans/stream-pipeline without Composer

Stream Pipeline

What is it?

A Stream based pipeline pattern implementation.

The Pipeline pattern uses ordered stages to process a sequence of input values. Each implemented task is represented by a stage of the pipeline. You can think of pipelines as similar to assembly lines in a factory, where each item in the assembly line is constructed in stages.

Features

• Fluent API / Chaining
  Chain methods like map, filter, reduce in a readable, functional style.

• Lazy evaluation
  The pipeline does not execute any operations until a terminal method like collect() or forEach() is called.
  Each element is processed one at a time through the entire chain, minimizing memory usage and allowing infinite or very large data streams.

• Lightweight and simple
  No dependencies and easy to integrate into any project.

• Common functional operations included
  map, filter, reduce, flatMap, distinct, limit, skip...

• Generics support via docblocks
  Compatible with Psalm/PHPStan for static type checking.

• Immutable style
  Each operation returns a new pipeline instance, avoiding side effects.

• Works with any iterable
  Supports arrays, generators, or any PHP iterable.

• Explicit terminal operations
  Methods like collect() and forEach() allow controlled consumption of data.

How it works

Stream pipeline allows you to go from writing expressions like:

to writing functional expressions like:

Getting started

The library is available as a Composer package on Packagist.org.

To install in your project, just run:

After this runs successfully, you can include the main class in your application logic:

Usage

You can initialize an Stream to use it:

A Stream object exposes several methods to operate with its elements:

The Stream class is immutable, so each chaining method returns a new Stream.

The execution of a Stream is lazy, so the elements are iterated just one time only when a terminal operation (forEach, reduce, toArray, collect...) is called.

Pipe operations

Each method allows a callable argument:

The library exposes some common operations to better readability:

Please see the Javadoc for more information.

Stream Methods

Initialization static operations:

• of(...$elements): StreamInterface
• fromIterable(iterable $collection): StreamInterface
• iterate($initialValue, callable $stepOperation): StreamInterface

Pipe operations:

• map(callable $operation): StreamInterface
• filter(callable $operation): StreamInterface
• peek(callable $operation): StreamInterface
• tap(callable $operation): StreamInterface (alias of peek).
• limit(int $limit): StreamInterface
• skip(int $number): StreamInterface
• distinct(?callable $distinctBy = null): StreamInterface
• flatMap(?callable $operation = null): StreamInterface
• concat(iterable $elements): StreamInterface
• takeWhile(callable $operation): StreamInterface
• dropWhile(callable $operation): StreamInterface

Terminal operations:

• findFirst()
• count(): int
• forEach(callable $callback): void
• anyMatch(callable $condition): bool
• allMatch(callable $condition): bool
• noneMatch(callable $condition): bool
• reduce(callable $operation, $initialValue)
• toArray(bool $preserveKeys = false): array
• collect(?callable $collector)

All callable functions receive: function ($currentElement, $index, $originalIndex) as arguments. Example:

Pre-defined Collectors

There are pre-defined collector functions with some common operations. You can use them with the terminal operator collect():

• Collectors::join(string $delimiter = '')
• Collectors::sum(?callable $mapper = null)
• Collectors::groupBy(?callable $classifier = null, ?callable $mapper = null)
• Collectors::groupAndReduceBy(?callable $keysMapper = null, ?callable $valuesMapper = null, ?callable $reducer = null)

For example:

Iterator classes

• NumberGenerator: a number generator with an optional step.

Example:

Operation classes

• Logical: logical operations (such as identity, true, false...).
• Numbers: numbers operations.
• Objects: generic objects operations.
• Strings: string utils and functions.
• Values: polimorphic values operations.