PHPackages                             gabrielalmir/maybe - PHPackages - PHPackages  [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register)

1. [Directory](/)
2. /
3. [Utility & Helpers](/categories/utility)
4. /
5. gabrielalmir/maybe

ActiveLibrary[Utility & Helpers](/categories/utility)

gabrielalmir/maybe
==================

Functional primitives for PHP: Option and Result types inspired by Rust

0.2.0(2mo ago)02MITPHPPHP >=7.4CI passing

Since Feb 26Pushed 2mo agoCompare

[ Source](https://github.com/gabrielalmir/maybe)[ Packagist](https://packagist.org/packages/gabrielalmir/maybe)[ RSS](/packages/gabrielalmir-maybe/feed)WikiDiscussions main Synced 1mo ago

READMEChangelogDependencies (5)Versions (5)Used By (0)

Maybe (v0.2.0)
==============

[](#maybe-v020)

`Maybe` is a PHP library for explicit and predictable business logic.

It combines 5 main building blocks:

- `Option`: safe flow for optional values
- `Result`: typed success/error without exceptions as control flow
- `Schema`: immutable parsing and validation
- `DTO`: validated mapping for input objects
- `Async`: concurrent execution via processes (`proc_open`) focused on PHP 7.4 + Windows + CI3

Requirements
------------

[](#requirements)

- PHP `>= 7.4`
- Composer

Installation
------------

[](#installation)

```
composer require gabrielalmir/maybe
```

Dependencies
------------

[](#dependencies)

- Main runtime: no extra mandatory dependencies
- `Async` module: uses `opis/closure` for closure serialization

API Overview
------------

[](#api-overview)

### Option

[](#option)

```
use Maybe\Option\Option;

$name = Option::fromNullable($payload['name'] ?? null)
    ->map('trim')
    ->flatMap(static function (string $value): Option {
        return $value === '' ? Option::none() : Option::some($value);
    })
    ->unwrapOr('guest');
```

Main methods:

- `map(callable $fn): Option`
- `flatMap(callable $fn): Option`
- `match(callable $onSome, callable $onNone)`
- `unwrap()`, `unwrapOr($default)`
- `isSome()`, `isNone()`

### Result

[](#result)

```
use Maybe\Result\Result;

function loadUser(int $id): Result
{
    if ($id  $id, 'name' => 'Ana']);
}

$message = loadUser(10)->match(
    static fn (array $user): string => 'User: ' . $user['name'],
    static fn (string $error): string => 'Error: ' . $error
);
```

Main methods:

- `map(callable $fn): Result`
- `mapErr(callable $fn): Result`
- `match(callable $onOk, callable $onErr)`
- `unwrap()`, `unwrapErr()`
- `isOk()`, `isErr()`

### Schema

[](#schema)

```
use Maybe\Schema\Schema;

$schema = Schema::shape([
    'email' => Schema::string()->trimmed()->min(5),
    'age' => Schema::int()->min(18),
]);

$result = $schema->safeParse([
    'email' => '  user@example.com  ',
    'age' => 23,
]);
```

Available builders:

- `Schema::string()`, `Schema::int()`, `Schema::bool()`, `Schema::date()`
- `Schema::enumeration([...])`
- `Schema::arrayOf(...)`
- `Schema::shape([...])`
- `Schema::option(...)`

### DTO

[](#dto)

```
use Maybe\DTO\DTO;
use Maybe\Schema\ObjectSchema;
use Maybe\Schema\Schema;

final class CustomerDTO extends DTO
{
    /** @var string */
    public $email;

    private function __construct(string $email)
    {
        $this->email = $email;
    }

    public static function schema(): ObjectSchema
    {
        return Schema::shape([
            'email' => Schema::string()->trimmed()->min(5),
        ]);
    }

    protected static function fromValidated(array $validated)
    {
        return new self($validated['email']);
    }
}

$dtoResult = CustomerDTO::fromArray(['email' => 'ana@example.com']);
```

Entry points:

- `DTO::fromArray($input)` returns `Result`
- `DTO::parse($input)` throws an exception on validation error

### Async

[](#async)

```
$result = await(async(static function (): int {
    usleep(100000);
    return 42;
}));
```

Features:

- `async(callable $task, array $args = [], array $options = [])`
- `await($futureOrArray)`
- `Async::all([...])`
- `Async::race([...])`
- `Async::pool($tasks, $limit)`
- `AsyncFuture::then()->catch()->finally()->resolve()`
- `pending()`, `cancel()`, per-task timeout (`['timeout' => 2.5]`)

Functional Helpers
------------------

[](#functional-helpers)

The following functions are auto-loaded:

- Option/Result: `some()`, `none()`, `fromNullable()`, `ok()`, `err()`
- Schema: `stringSchema()`, `intSchema()`, `boolSchema()`, `dateSchema()`, `enumSchema()`, `arraySchema()`, `objectSchema()`, `optionSchema()`
- Async: `async()`, `await()`

Global aliases are also available for CI3 compatibility:

- `Async`
- `Async_future`

CodeIgniter 3
-------------

[](#codeigniter-3)

With Composer loaded in the project:

```
$this->load->library('async');

$value = await(async(static function (): int {
    return 123;
}));
```

Async Limitations
-----------------

[](#async-limitations)

- Processes are isolated (no shared memory)
- Non-serializable resources must be recreated in the child process
- There is process spawn overhead per task

Development
-----------

[](#development)

```
composer lint
composer test:async
```

> Note: the legacy `test` runner uses Pest 1.x. On very new PHP versions, prefer `test:async` to validate the async module.

Async Examples
--------------

[](#async-examples)

Run the examples directly:

```
php examples/async-basic.php
php examples/async-all-race.php
php examples/async-pool.php
php examples/async-chain-timeout-cancel.php
```

###  Health Score

31

—

LowBetter than 68% of packages

Maintenance86

Actively maintained with recent releases

Popularity2

Limited adoption so far

Community6

Small or concentrated contributor base

Maturity27

Early-stage or recently created project

 Bus Factor1

Top contributor holds 100% of commits — single point of failure

How is this calculated?**Maintenance (25%)** — Last commit recency, latest release date, and issue-to-star ratio. Uses a 2-year decay window.

**Popularity (30%)** — Total and monthly downloads, GitHub stars, and forks. Logarithmic scaling prevents top-heavy scores.

**Community (15%)** — Contributors, dependents, forks, watchers, and maintainers. Measures real ecosystem engagement.

**Maturity (30%)** — Project age, version count, PHP version support, and release stability.

###  Release Activity

Cadence

Every ~4 days

Total

3

Last Release

72d ago

### Community

Maintainers

![](https://www.gravatar.com/avatar/2f48e97cd162855594f0c0faab10f8b11ef5342c5cc0dbf6d7675261629512f8?d=identicon)[gabrielalmir](/maintainers/gabrielalmir)

---

Top Contributors

[![gabrielalmir](https://avatars.githubusercontent.com/u/98054504?v=4)](https://github.com/gabrielalmir "gabrielalmir (14 commits)")

---

Tags

asyncfunctionalmonadoptionphp7result-patternwindowsphpoptionresultfunctionalmonadmaybe

###  Code Quality

TestsPest

Static AnalysisPHPStan

Type Coverage Yes

### Embed Badge

![Health badge](/badges/gabrielalmir-maybe/health.svg)

```
[![Health](https://phpackages.com/badges/gabrielalmir-maybe/health.svg)](https://phpackages.com/packages/gabrielalmir-maybe)
```

###  Alternatives

[lambdish/phunctional

λ PHP functional library

3612.0M23](/packages/lambdish-phunctional)[chippyash/monad

Functional programming Monad support

2828.1k8](/packages/chippyash-monad)[mpetrovich/dash

A functional programming library for PHP. Inspired by Underscore, Lodash, and Ramda.

10428.9k1](/packages/mpetrovich-dash)[transprime-research/piper

PHP Pipe method execution with values from chained method executions

174.6k2](/packages/transprime-research-piper)

PHPackages © 2026

[Directory](/)[Categories](/categories)[Trending](/trending)[Changelog](/changelog)[Analyze](/analyze)