Home > Raku > Iterative golfing

Iterative golfing

Lured by the Weekly, I went on twitter and lost an hour because lizmat could not resist.

sub sc($str) {
      .chars == 1 ?? .lc !! .lc.flip.tc.flip
    } ).join
  }).join(" ")
say sc "sarcasmcase FOR YOU";
# sArCaSmCaSe fOr yOu

That’s nice and short but in my eyes, showing off on twitter should involve more Raku features. My first shot as follows.

sub sc($_) {
        my @c = &uc, &lc;
        .comb».map({ @c = @c[1..*,0].flat; @c[0]($_);  }).join

I’m trying to use a functional approach by building a list of functions and then rotating that list while I apply the first element in that list. Thus, &lc and &uc are called alternating. That works but looks a bit line noisy.

sub sc($_) {
    my \c = (|(&lc, &uc) xx *).cache;
    .words».&{ (.comb Z c.clone).map( -> ($c, &c) { c($c) }).join }.flat;

By building an infinite list of functions, I don’t need to mutate that list. Just using Z will create the right amount of iterators in the background to alternate &lc and &uc. I’m still not happy with the map-part.

sub sc($_) {
    .words».&{ (.comb »,» (&lc, &uc)).flat.map({ &^b($^a) }).join }.flat

That’s much shorter and I don’t need to build the infinite list of functions by hand any more. Of cause, that list still exists. It is just hidden within the hyper operator. I’m still not happy with the .map. I’m building a pair of a value and a function-object. If I could .assume, I would not need the .map at all.

multi sub infix:<⊙>(&c, +@a) {
sub sc($_) {
    .words».&{ ((&lc, &uc) «⊙« .comb)».().join }

By turning .assuming into an infix, I can use it straight in the hyper-operator. The resulting list of .assumed function can then be called via »..

Infix operators allow us to play functional tricks with very few keystrokes. We already got ∘ to combine functions. It may make sense to include ⊙ into CORE too. I’m not sure about its Texas-variant thought. Any suggestions?

Categories: Raku
  1. joking
    January 28, 2022 at 09:00

    I came up with the regex-style `{.lc.&{S:g{\S<(.}=$/.uc}}` or `{S:g{\S<(.}=$/.uc}o&lc`, though I wanted to do `S:g{\S<(.}.=&uc`, but unfortunately you can't use `.=` in that fashion for substitutions. Come join us on code.golf if you feel like doing some more golfing!

  1. January 31, 2022 at 14:01

Leave a Reply

Please log in using one of these methods to post your comment:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

%d bloggers like this: