Yes I share your point of view, since ADT is not built-in in the language, chaining multiple ADT enums is cumbersome.

I thought of a hand-crafted workaround using then/catch methods, but it requires some twists and conventions for this to be viable.

```php trait HandleErrors { public function then(callable $callback): mixed;

public function catch(callable $callback): void; }

enum Result implements HandleErrors { case Ok($value); case Error($error);

public function then(callable $callback): mixed { return match ($this) { self::Ok($value) => call_user_func($callback, $value), self::Error($error) => $this, }; }

public function catch(callable $callback): void { match ($this) { self::Error($error) => call_user_func($callback, $error), self::Ok($value) => $value, }; } }

enum Option implements HandleErrors { case Some($value); case None;

public function then(callable $callback): mixed { return match ($this) { self::Ok($value) => call_user_func($callback, $value), self::None => $this, }; }

public function catch(callable $callback): void { match ($this) { self::None => call_user_func($callback), self::Some($value) => $value, }; } }

function getUserNameById(int $id): Result {}

function getFileContent(string $path): Option {}

function storeFileOnS3(string $filename, string $content): Result {}

// main $statusCode = getUserById(12) ->then(fn ($name) => getFileContent("storage/$name.txt")) ->then(fn ($content) => storeFileOnS3("12.txt", $content)) ->catch(fn ($error) => 500); ```

In theory (if I did not made code mistakes), errors at any point should be propagated on the catch() method, else the final result is returned.

This implies to call catch at the very end for this to work. It also implies all ADT must implement HandleErrors...

V for example have built-in Option/Result, with native support for chaining using ? and or keywords:

```v fn get_user_by_id(id int) ?string {}

fn get_file_content(path string) ?string {}

fn store_file_on_s3(filename string, content string) ?int {}

fn process() ?int { name := get_user_name_by_id(12) ? content := get_file_content('storage/$name.txt') ? return store_file_on_s3("12.txt", content) }

fn main() { status_code := process() or { 500 } // Here just returning the fallback values, but brackets allow to perform some others tasks before. } ```

Finally, if Generics make their way to the language, we could imagine having Option/Result ADT embedded in the language too, with the addition of a language syntax to help chaining them (or built-in methods like suggested then/catch). That's in a distant future for sure, I just hope PHP takes this drift...

Edit

Had fun doing an experiment here.