The trick seems to be to replace the 'items' sub-element:

use strict;
use warnings;
use Data::Dump qw();
use Data::Rmap qw();

my $initial = [note => [shopping => ['item']]];

Data::Rmap::rmap_array {
    return $_ if $_->[0] ne 'shopping'; # Ignore non-shopping entries

    my @item= map {[item => $_]} qw(bread butter beans);

    $_->[1] = ['shopping', @item];
    Data::Rmap::cut ($_);
} $initial;

print Data::Dump::dump ($initial), "\n";
[download]

Prints:

[
  "note",
  [
    "shopping",
    [
      "shopping",
      ["item", "bread"],
      ["item", "butter"],
      ["item", "beans"],
    ],
  ],
]
[download]

That is not the target structure specified in the OP:

    [
          'note',
          [
            'shopping',
            [ item => 'bread' ],
            [ item => 'butter' ],
            [ item => 'beans' ],
            ]
        ];
[download]






The mantra of every experienced web application developer is the same: thou shalt separate business logic from display. Ironically, almost all template engines allow violation of this separation principle, which is the very impetus for HTML template engine development.

-- Terence Parr, "Enforcing Strict Model View Separation in Template Engines"

The structure may not be right, but the sense is and I see your solution takes elements from my code so it wasn't all loss was it? You may find the following trivial variant more to your liking:

use strict;
use warnings;
use Data::Dump qw();
use Data::Rmap qw();

my $initial = [note => [shopping => ['item']]];

Data::Rmap::rmap_array {
    return $_ if $_->[0] ne 'shopping'; # Ignore non-shopping entries

    my @item= map {[item => $_]} qw(bread butter beans);
    $_ = ['shopping', @item];
    Data::Rmap::cut ($_);
} $initial;

print Data::Dump::dump ($initial), "\n";
[download]

prints:

[
  "note",
  [
    "shopping",
    ["item", "bread"],
    ["item", "butter"],
    ["item", "beans"],
  ],
]
[download]

True laziness is hard work

#!/usr/bin/perl

use strict;
use warnings;

use Data::Rmap qw(:all);

my @item = ('bread', 'butter', 'beans');

my $initial =
  [
    note =>
      [
         shopping =>
           [ 
             $item[0] =>
             $item[1] =>
             $item[2] =>
           ],
      ],
];

use Data::Dumper;
my ($dump) = rmap_array {
  
  if ($_->[0] eq 'shopping') {
    my @item;
    for my $item qw(bread butter beans) {
      push @item, [ item => $item ];
    }
    my $newdata = [ shopping => \@item ];
    cut($newdata)
  } else {
    $_;
  }

  } my @item ;

warn Dumper($initial, $dump);
[download]

It wouldn't do 'item' => 'bread' but it would do bread =>. This was as close as I could get

This data is for consumption by new_from_lol in HTML::Element.




The mantra of every experienced web application developer is the same: thou shalt separate business logic from display. Ironically, almost all template engines allow violation of this separation principle, which is the very impetus for HTML template engine development.

-- Terence Parr, "Enforcing Strict Model View Separation in Template Engines"

I haven't used Data::Rmap before so others may have better answers. However, the following works and solves your problem.

use strict;
use warnings;

use Data::Rmap qw(:all);

my $initial = [ note => [ shopping => [ 'item' ] ] ];

use Data::Dumper;

# build a list of shopping items ** for reuse **
my @shopping_items;
for my $item qw(bread butter beans) {
    push @shopping_items, [ item => $item ];
}

my ($dump) = rmap_array {
 
  # If we get an arrayref whose first element is 'shopping'
  if ($_->[0] eq 'shopping') {
    # Make the second element the shopping list
    $_->[1] = [ @shopping_items ];
    # No need to drill down any further
    cut($_);
    
  } else {
    # if the arrayrefs first element is not 'shopping'
    # then simply pass it through
    $_;
  }

  } $initial;

warn Dumper($initial, $dump);
[download]

Thanks kcott. I've gone ahead and abstracted htis into a function. Now, I'm going to try to solve it at the level of 'items' instead of at the parent level.

use strict;
use warnings;

use Data::Rmap qw(:all);
use Data::Dumper;

my $initial_lol = [ note => [ shopping => [ item => 'sample' ] ] ];

#  In $initial_lol, the new child of shopping is shopping_items
my $new_lol = newchild($initial_lol, shopping => shopping_items());

warn Dumper($new_lol);



sub newchild {
  my ($lol, $parent_arrayref_label, $new_child)=@_;

  my ($mapresult) = rmap_array {
 

  if ($_->[0] eq $parent_arrayref_label) {
    $_->[1] = $new_child;
    cut($_);
  } else {
    $_;
  }

  } $lol;

  $mapresult;

}

sub shopping_items {
  my @shopping_items;
  for my $item qw(bread butter beans) {
    push @shopping_items, [ item => $item ];
  }
  \@shopping_items;
}
[download]






The mantra of every experienced web application developer is the same: thou shalt separate business logic from display. Ironically, almost all template engines allow violation of this separation principle, which is the very impetus for HTML template engine development.

-- Terence Parr, "Enforcing Strict Model View Separation in Template Engines"

tada! now I work at the item level instead of it's parent:

use strict;
use warnings;

use Data::Rmap qw(:all);
use Data::Dumper;

my $initial_lol = [ note => [ shopping => [ item => 'sample' ] ] ];

#  In $initial_lol, the new child of shopping is shopping_items
my $new_lol = newnode($initial_lol, item => shopping_items());

warn Dumper($new_lol);



sub newnode {
  my ($lol, $node_label, $new_node)=@_;

  my ($mapresult) = rmap_array {
 

  if ($_->[0] eq $node_label) {
    $_ = shopping_items();
    cut($_);
  } else {
    $_;
  }

  } $lol;

  $mapresult;

}

sub shopping_items {
  my @shopping_items;
  for my $item qw(bread butter beans) {
    push @shopping_items, [ item => $item ];
  }
  \@shopping_items;
}
[download]






The mantra of every experienced web application developer is the same: thou shalt separate business logic from display. Ironically, almost all template engines allow violation of this separation principle, which is the very impetus for HTML template engine development.

-- Terence Parr, "Enforcing Strict Model View Separation in Template Engines"

use strict;
use warnings;

use Data::Rmap qw(:all);

my $initial =
  [
    note =>
      [
    shopping =>
      [ 'item' ]
     ]
     ];

use Storable qw(dclone);
my $clone = dclone $initial;

use Data::Dumper;
my ($dump) = rmap_all {

  if (ref  and $_->[0] eq 'shopping') {
    my @item = map { [ item => $_ ] } qw(bread butter beans);
    warn Dumper(\@item);
    my $newdata = [ shopping => \@item ];
    $_ = $newdata;
  } else {
    $_ = $_;
  }

} $clone ;

warn Dumper($initial, $dump);
[download]

Why:

  } else {
    $_ = $_;
[download]

which does nothing, and why:

    my $newdata = [ shopping => \@item ];
    $_ = $newdata;
[download]

when you could just:

    $_ = [ shopping => \@item ];
[download]

or maybe even:

    $_ = [shopping => [map {[item => $_]} qw(bread butter beans)]];
[download]

for the whole if block.

True laziness is hard work

}
else {
    $_ = $_;
}
[download]

#!/usr/bin/perl

use strict;
use warnings;
use Data::Rmap qw(:all);
use Data::Dump qw(dump);
use Storable qw(dclone);

my $initial = ['note', ['shopping', ['item']]];
my $clone = dclone $initial;

my($dump) = rmap_all {
  if( ref and $_->[0] eq 'shopping' ) {
    my @item = map { [ 'item' => '=>' => $_ ] } qw(bread butter beans)
+;
    my $newdata = [ shopping => \@item ];
    $_ = $newdata;
  }
  else {
    $_
  }
}
$clone;
print dump($dump);
[download]