╔═╗╦  ╔═╗╔╦╗╦ ╦╔═╗╔═╗╔╦╗
        ╠╣ ║  ╠═╣ ║ ╠═╣║╣ ╠═╣ ║║
        ╚  ╩═╝╩ ╩ ╩ ╩ ╩╚═╝╩ ╩═╩╝
          ╔═╗╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╦═╗
          ║ ║╠═╝║╣ ╠╦╝╠═╣ ║ ║ ║╠╦╝
          ╚═╝╩  ╚═╝╩╚═╩ ╩ ╩ ╚═╝╩╚═

============================================================================

The babycart operator interpolates in list context. But what if you
need scalar context? What if you want to interpolate a single value,
not a list?

Meet the flathead:

    ${\  }

The babycart's scalar cousin. Same trick, different context.

============================================================================

PART 1: THE TRICK
-----------------

    my @items = qw(apple banana cherry);

    print "Items: @{[ @items ]}\n";       # list context: apple banana cherry
    print "Count: ${\( scalar @items )}\n";   # scalar context: 3

Or more elegantly for simple expressions:

    print "Sum: ${\( $x + $y )}\n";

The ${\} forces scalar context, interpolating a single value.

============================================================================

PART 2: HOW IT WORKS
--------------------

Break it down:

    ${\( EXPRESSION )}

    ( EXPRESSION )     Evaluate expression in scalar context
    \( ... )           Create a reference to that scalar value
    ${ ... }           Dereference it for interpolation

It's the scalar mirror of babycart's array trick:

    @{[ ]}    Array ref, list context, array deref
    ${\( )}   Scalar ref, scalar context, scalar deref

          .--.
         |o_o |
         |:_/ |
        //   \ \
       (|     | )
      /'\_   _/`\
      \___)=(___/

============================================================================

PART 3: WHY THE NAME
--------------------

Imagine a flathead screwdriver:

    ${\()}

The $ is the handle, the {\()} is the flat blade. You're using it to
pry out a single scalar value.

Not the most compelling visual, but Perl naming is weird. The name
stuck because it contrasts with babycart - one for lists, one for
scalars.

============================================================================

PART 4: WHEN TO USE
-------------------

Babycart usually works fine:

    print "Length: @{[ length($str) ]}\n";

But flathead is cleaner when you're explicitly working with scalars:

    print "Length: ${\( length($str) )}\n";

The difference matters when context matters:

    my @data = (1, 2, 3);
    
    # This gives you the list
    print "Data: @{[ @data ]}\n";      # 1 2 3
    
    # This gives you the count
    print "Count: ${\( @data )}\n";    # 3

============================================================================

PART 5: SIMPLIFIED FORM
-----------------------

For simple references, you can shorten it:

    my $value = 42;
    print "Value: ${\$value}\n";

No parentheses needed when you're just referencing a variable.

But for expressions:

    print "Sum: ${\( $x + $y )}\n";

The parentheses are required to group the expression.

============================================================================

PART 6: HASH KEYS
-----------------

Useful for interpolating hash lookups:

    my %user = (name => 'Alice', age => 30);

    print "Name: ${\$user{name}}\n";
    print "Age: ${\$user{age}}\n";

Cleaner than concatenation:

    print "Name: " . $user{name} . "\n";

============================================================================

PART 7: METHOD CALLS
--------------------

Interpolate object method results:

    my $obj = SomeClass->new();
    print "Status: ${\( $obj->get_status() )}\n";
    print "ID: ${\( $obj->id() )}\n";

This keeps method calls inside the string instead of breaking them
out with concatenation.

============================================================================

PART 8: VS BABYCART
-------------------

When does it matter?

    my @nums = (1, 2, 3);

    # Babycart - list context
    print "Array: @{[ @nums ]}\n";      # 1 2 3

    # Flathead - scalar context
    print "Count: ${\( @nums )}\n";     # 3

    # Babycart with explicit scalar
    print "Count: @{[ scalar @nums ]}\n";  # 3

The last two are equivalent. Use whichever reads better to you.

For functions that behave differently in list vs scalar context:

    # localtime in list context = (sec, min, hour, ...)
    print "List: @{[ localtime ]}\n";      # 34 25 14 6 0 125 1 5 0

    # localtime in scalar context = "Mon Jan  6 14:25:34 2025"
    print "Time: ${\( scalar localtime )}\n";

============================================================================

PART 9: IN HEREDOCS
-------------------

Both operators work in heredocs:

    print <<"END";
    Report for ${\( scalar localtime )}
    
    Items: @{[ @items ]}
    Total: ${\( $count )} items
    
    Average: ${\( sprintf "%.2f", $sum / $count )}
    END

Mix and match based on what makes sense.

============================================================================

PART 10: PRACTICAL EXAMPLE
--------------------------

Generate a status line:

    my @errors = get_errors();
    my @warnings = get_warnings();
    my $uptime = get_uptime();

    print <<"STATUS";
    System Status
    =============
    Uptime: ${\( format_duration($uptime) )}
    Errors: ${\( @errors )} (${\( @errors ? 'ALERT' : 'OK' )})
    Warnings: ${\( @warnings )}
    
    Recent errors:
    @{[ map { "  - $_\n" } @errors ]}
    STATUS

Flathead for counts and single values, babycart for lists.

============================================================================

PART 11: THE TRADE-OFF
----------------------

Flathead and babycart are clever. But they're not free:

    # Clear intent, easy to read
    my $count = scalar @items;
    print "Count: $count\n";

    # Clever, harder to read
    print "Count: ${\( @items )}\n";

Use these operators when they make code cleaner. Don't use them just
because you can. Readability wins.

============================================================================

                    ${\ }
                     |
                    [_]
                     |
                   scalar

         The babycart's single-minded cousin

============================================================================

japh.codes