How can I flatten the arguments to my subroutine into an array?

Question

Consider following script:

use strict;
use Data::Dumper;

my @arr=('1A','2A');
my $arr_ref=['1','2'];

sub routine1
{
my @arr=@_;
print Dumper(\@arr);
}

routine1(@arr,'one_A');

sub routine2
{
my $arr_ref=[@_];
print Dumper($arr_ref);
}

routine2($arr_ref,'one');

routine1 is using @arr and routine2 is using $arr_ref.

routine1 prints the following:

$VAR1 = [
         '1A',
         '2A',
         'one_A'
        ];

routine2 prints following:

$VAR1 = [
         [
           '1',
           '2'
         ],
         'one'
        ];

I want to continue using @_ and arr_ref in routine2 but want to come up with below output:

$VAR1 = [
         '1',
         '2'
         'one'
        ];

Can someone suggest the way out?

You're question is too vague for me.

kjprice
– kjprice

2013-03-30 18:40:38 +00:00
Commented Mar 30, 2013 at 18:40 — kjprice
– kjprice, Commented Mar 30, 2013 at 18:40

Joel Berger · Accepted Answer · 2013-03-31 04:48:24Z

3

Using the function ref you can see if a scalar is a reference (and if so, which type). In a simplistic case where only array references will be passed you can simply use this to flatten the inputs.

#!/usr/bin/env perl

use strict;
use warnings;

use Data::Dumper;

sub test {
  my @arr = map { ref() ? @$_ : $_ } @_;
  print Dumper \@arr;
}

test( ['a', 'b'], 1 );

As a side benefit, this code will die with a message if a reference to another type is passed, since you attempt to deference as an array. If you need to handle more, you will need to check the reference type. This starts to build in complexity quickly.

#!/usr/bin/env perl

use strict;
use warnings;

use Data::Dumper;

sub test {
  my @arr = map { 
    my $type = ref;
    if ( ! $type ) {
      $_;
    } elsif ( $type eq 'ARRAY' ) {
      @$_;
    } elsif ( $type eq 'HASH' ) {
      %$_;
    } else {
      ()
    }
  } @_;
  print Dumper \@arr;
}

test( ['a', 'b'], { p => 'q' }, 1 );

By returning an empty list for other reference types I silently ignore all other reference types. Or perhaps you would rather force stringification on other reference types.

...
} else {
  "$_";
}
...
test( ['a','b'], sub{}, bless({},'MyClass'), 1 );

Of couse which of these handlings to use depends on you use case.

edited Mar 31, 2013 at 4:48

answered Mar 30, 2013 at 18:42

Joel Berger

20.3k5 gold badges52 silver badges106 bronze badges

Sign up to request clarification or add additional context in comments.

4 Comments

Sachin S Over a year ago

Inside the subroutine, can we not take the values of @_ directly in array_reference (instead of in the @arr)? Is that possible?

Joel Berger Over a year ago

In order to flatten the references, you are going to have to iterate through the structure. I suppose you could try to pack it back into @_, but why would you want to?

Zaid Over a year ago

Why not just map @$_, @_?

Joel Berger Over a year ago

@Zaid, because that doesn't work. Did you try it? Array deref on a scalar.

Andy Lester · Accepted Answer · 2013-03-31 05:48:05Z

1

Just wrote this the other day at work.

sub flatten {
    return map { ref($_) ? flatten(@{$_}) : ($_) } @_;
}

answered Mar 31, 2013 at 5:48

Andy Lester

94.2k16 gold badges106 silver badges162 bronze badges

3 Comments

Zaid Over a year ago

I'm struggling to see what this would buy over a simple map @$_, @_

darch Over a year ago

@zaid Well, it flattens a heterogeneous list and also flattens more-deeply-nested lists. In other words, it works on (5, [6], [7, 8], [ [ 9, 4], 5]).

Zaid Over a year ago

@darch : Joel made me realize that

Borodin · Accepted Answer · 2013-03-30 22:13:55Z

0

This program shows a subroutine flatten that will flatten a mixed list of simple data and array references, nested to any level.

use strict;
use warnings;

use Data::Dump;

my @arr = qw/ 1A 2A /;
my $arr_ref = [1, 2];

sub flatten;

routine1(@arr, 'one_A');
routine2($arr_ref, 'one');

sub routine1 {
  my @arr=@_;
  dd \@arr;
}

sub routine2 {
  my $arr_ref = [flatten @_];
  dd $arr_ref;
}

sub flatten {
  my $i = 0;
  while ($i < @_) {
    my $item = $_[$i];
    if (ref $item eq 'ARRAY') {
      splice @_, $i, 1, @$item;
    }
    else {
      ++$i;
    }
  }
  @_;
}

output

["1A", "2A", "one_A"]
[1, 2, "one"]

answered Mar 30, 2013 at 22:13

Borodin

127k9 gold badges72 silver badges146 bronze badges

Collectives™ on Stack Overflow

How can I flatten the arguments to my subroutine into an array?

3 Answers 3

4 Comments

3 Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

4 Comments

3 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related