DEV Community: lray138

Whoopsies (aka semantic intent)

lray138 — Sun, 19 Apr 2026 15:53:06 +0000

I caught myself about to make a mistake:

  $t = tryCarbonPostMeta("options", $p->ID)
                ->bind(function(Lst $l) {
                    return $l->filter(function(array $k) {
                        return $k['price'] !== '';
                    })
                    ->tryHead();
                })
                ->bind(function(Kvm $options) use ($p) {
                    dump($options);
                    die;
                    return tryPartial("/site/menu-item-priced-options.php", [
                        "post" => $p
                    ]);
                });

tryHead did allow me a valid way to use bind here, but I realized, I was locking myself into one option.

blah blah blah

the finished chain looks like this:

return tryCarbonPostMeta("options", $p->ID)
                ->bind(function(Lst $l) use ($data) {
                    return $l->filter(function(array $k) {
                        return $k['price'] !== '';
                    })
                    ->pipe(function(Lst $l) use ($data) {
                        return $l->tryHead()
                            ->fold(function() use ($data) {
                                return tryPartial("/site/partials/menu-item.php", $data);
                            }, function(Kvm $x) use ($data, &$l){
                                return tryPartial("/site/partials/menu-item-priced-options.php", wrap($data)
                                    ->tap(function($x) use (&$l) {
                                        if($x->prop('price')->get() !== '') {
                                            $l = $l->unshift([
                                                'description' => $x->prop('desc')->get(),
                                                'price' => $x->prop('price')->get()
                                            ]);
                                        }
                                        return $x;
                                    })
                                    ->set('optionsHtml', 
                                        $l->map(fn($x) => tryPartial("/site/partials/item-option.php", $x)->getOrElse(Str::of('')))
                                        ->join(tryPartial("/site/partials/or-line.php", [])->getOrElse(Str::of('')))
                                    )->get()

                                );
                            });
                    });
                })
                ->getOrElse(Str::of(''))
                ;

I would say this chunk would be the end of the line of the functional journey I started many years ago...

culminating in tap vs. pipe, map vs bind, etc...

weeeee.....

It's all the same, PT 2...

lray138 — Mon, 06 Apr 2026 18:28:39 +0000

ahh...

actually this was going to be in response to all 'social' sites being the same and when I log ...

nah

I was looking at

    var container_class = ls.try("fluid")
        .fork(
            () => 'container',
            (x) => x.isTrue() ? "container-fluid" : "container"
        );

and again, this is me trying to apply these functional concepts to my particular domain of expertise, which is content management.

WTF is going on here? tracking back I see

let ls = Kvm.of(locals);

I don't like that variable name and I think a helper like tryProp('prop', Kvm ...) or ... see here is where the endleess loop and eternal madness can start.

again, bouncing between a PHP and a JavaScript implementation of the same concept. A single approach to programming through the lense of functional programming.

if the method was tryProp, then I would understand what was going on at a glance. it's not.. it's not clear what is going on.

then... I'm mis using "fork" it shoudl at least be called "fold" here...

I periodically entertained "match" but I think GPT was leading me down the wrong direction...

so...

we want it to be the same ... PHP to JS the methods and approach. We have dubbed the toolkit Pipeline.

It's all the same...

lray138 — Mon, 06 Apr 2026 18:19:17 +0000

The Biggest Mind F**k

lray138 — Sun, 05 Apr 2026 16:00:38 +0000

"this will be the day"

reality,

It's just another day keep moving.

...

function get_config_page(string $template): ?WP_Post
{
    $slug = basename($template, '.php');

    $q = new WP_Query([
        'post_type'      => 'page',
        'posts_per_page' => 1,
        'name'           => $slug,
        'meta_query'     => [
            [
                'key'   => '_wp_page_template',
                'value' => 'templates/template-config.php',
            ],
        ],
    ]);

    return $q->have_posts() ? $q->posts[0] : null;
}

is obviously a Claude generated functoin since I use pascal case.

I will change this to tryConfigPage where now try is the version of "get" that returns a Result.

hermm

// $sections->forEach( function( Kvm $s, Num $n ) use ( &$out, $type, $data ) {
//     $out = $out->append( handlePageSection(
//         $s->set( 'index', $n )
//             ->set( 'id', Str::of("s")->append($n) ) 
//             ->set( 'complex_field', $type )
//             ->set( 'data', $data )
//     ) );
// } );

$out = $sections->reduce(function(array $acc, array $x) use (&$out, $type, $data) {
    $x = Kvm::of($x);
    return [$acc[0]->append(handlePageSection(
        $x->set( 'index', $acc[1] )
            ->set( 'id', Str::of("s")->append($acc[1]) ) 
            ->set( 'complex_field', $type )
            ->set( 'data', $data )
    )), $acc[1] + 1];
}, [Str::of(''), 0]);

return Str::of($out[0]);

P.S.

I don't care if this is all over the place and doesn't make sense...

I will hopefully come back and clean this up and turn it into something valueble.

Mad For Monads

lray138 — Mon, 30 Mar 2026 03:15:04 +0000

When I loaded up this site this article sat at the top of the feed. https://dev.to/sylwia-lask/how-i-almost-burned-out-doing-everything-right-31j6?

Well, I'm burned out. I've been burned out.

I never even wanted to be a programmer... how did I get here?

function tryPartial($partial, $args = null): Result
{
    $result = getPartialCallable(Str::of($partial))
        ->map(fn($callable) => fn(array $args) => Str::of($callable($args)));

    if (func_num_args() >= 2) {
        return $result->ap(Result::of($args));
    }

    return $result;
}

that was the updated function from:

function tryPartial($partial, $args = []): Result {
     $out = getPartialCallable(Str::of($partial))
         ->map(fn($callable) => Str::of($callable($args)));
     return $out;
}

Where I realized if tryPartial was curried I could return the Result which would contain the functional component and then I could use ap on the Result to apply the data and return the result of the function with is a string of HTML.

Going Mad With Monads

lray138 — Wed, 25 Mar 2026 01:57:04 +0000

Years ago now... sometime back in 2018, or 2019, I bought a book called "Pro PHP Functional Programming".

Functional programming was all the rage back then, and so I decided to learn in a language I was most familiar with.

At some point deep in the book the author mentioned NOT recommending using Monads in PHP. First, the whole point of the book, in my mind, was to learn about "The Mysterious Monad", and 2nd, the one way to get me to do something is tell me not to do it. Thus began the great misadventure I pray is finally coming to an end.

I had also read a book by Christopher Pitt "Typed PHP" and combining those ideas, with my desire to utilize these functional techniques in my content management job, led me to go down all sorts of rabbit holes in search of the "ultimate toolbox" or "ultimate approach" ... the deeper understanding that would make me that mythical 10x-ninja badass and then I could go back to focusing on music while my system starting bring in passive income.

Light backstory aside, I am coming here because I am attempting to document the final stages of this package I have been putting together in the hopes that my work might be of some value to someone somewhere in the near future. Hopefully that person is myself.

Ha.

So, I'm actually refactoring some code based on a previous iteration of this content management layer I've been working on, where I mistakenly thought it would be cool to give everyting a bind method and make types obey the monadic interface.

After the ADHD burnout recharge, I came back and realized I was a little off.

Finally, it clicked. I needed a "pipe" method that would allow me to continue method chaining, thus creating a nice pipeline.

So.. Here "all_images" is a collection/list (Lst) of images coming from a WordPress instance. We take those images and map partial components on the data and reduce it to a Str (again influenced by Christopher Pitt's Typed PHP book).

Since the "inc" function returns a Str type object, in my mind using bind made sense (at the time). But I have since realized the error of my ways and removed it, which led to the dreaded Fatal Error. Luckily, I had done some deep thinking with the aid of ChatGPT and implemented a "pipe" method that would allow me access to the whole object, and the best part is my return type can be whatever I want, not that it matters in this example.

So...

$all_images = $all_images
    ->map(fn($x) => inc("partials/masonry-gallery/card-wrap")([
        "content" => inc("partials/masonry-gallery/card")($x),
        "image" => $x['img_src'],
    ]))
    ->reduce(fn(Str $acc, $x) => $acc->append($x), Str::of(""))
    ->bind(fn($x) => inc("partials/masonry-gallery/section")([
        "content" => $x
    ]))
    ;

becomes

$all_images = $all_images
    ->map(fn($x) => inc("partials/masonry-gallery/card-wrap")([
        "content" => inc("partials/masonry-gallery/card")($x),
        "image" => $x['img_src'],
    ]))
    ->reduce(fn(Str $acc, $x) => $acc->append($x), Str::of(""))
    ->pipe(fn($x) => inc("partials/masonry-gallery/section")([
        "content" => $x
    ]))
    ;

alternatively I could map by extracting the return of the inc function:

$all_images = $all_images
    ->map(fn($x) => inc("partials/masonry-gallery/card-wrap")([
        "content" => inc("partials/masonry-gallery/card")($x),
        "image" => $x['img_src'],
    ]))
    ->reduce(fn(Str $acc, $x) => $acc->append($x), Str::of(""))
    ->map(fn($x) => inc("partials/masonry-gallery/section")([
        "content" => $x
    ])->get()
    ;

I do think it helps readability to provide the type in the function signature. Since being a "lazy programmer" is considered good I don't always do that.

$all_images = $all_images
    ->map(fn($x) => inc("partials/masonry-gallery/card-wrap")([
        "content" => inc("partials/masonry-gallery/card")($x),
        "image" => $x['img_src'],
    ]))
    ->reduce(fn(Str $acc, $x) => $acc->append($x), Str::of(""))
    ->pipe(fn(Str $x): Str => inc("partials/masonry-gallery/section")([
        "content" => $x
    ]))
    ;

So, going mad with Monads, and we don't even use a monad?

Yes, exactly.