Slash Boxes
NOTE: use Perl; is on undef hiatus. You can read content, but you can't post it. More info will be forthcoming forthcomingly.

All the Perl that's Practical to Extract and Report

The Fine Print: The following comments are owned by whoever posted them. We are not responsible for them in any way.
More | Login | Reply
Loading... please wait.
  • Very. Very. Cool.

    So it's alpha, with large blinking warning signs to stay away, etc. Is the alpha flag a matter of concept (unsound/fragile) or a matter of effort (just not done yet)?

    What's needed (if possible) to get it to a state so that people can use it?

    • Is the alpha flag a matter of concept (unsound/fragile) or a matter of effort (just not done yet)?

      It might be fragile. So far it's holding up well, but I haven't done anything major with it and I'm wary of building this on top of so much scary tech. Devel::Declare has a few bugs (it causes the debugger to spin like a top) that I hope mst will clear up shortly.

      Second is the prototyping syntax and behaviors. Since I'm creating, essentially, a new language feature here I'd like it to get knocked around some before locking it in place. I'm pretty happy with how it's come out, and if I stabilized with ju

      • On the matter of syntax, do you have any ideas on named arguments (i.e. hash/hash ref automatically unpacked into the variables)?

        It seems doable to me. If the signature is misc vars, but you pass in a single hash ref, then... *magic*

        • While they are definitely a possibility, and you're not the first
          person to ask for them, I'm wary of trying to mirror Perl 6's named parameters [] right now for a number of reasons. First, they're not
          necessary just now. Method::Signatures has a nice bag of problems to
          deal with already and the signature syntax is extensible. And I
          haven't given them a lot of thought.

          Second, Perl 6 has all sorts of magic at the caller's end to force
          named vs positional parameters. We have none of that. All we can do
          is, as you suggest, treat a hash ref as positional. But that leaves
          some ambiguity...

          method foo( $things ) {
          Class->foo({ things => 42 });

          What's in $things? Currently it's { things => 42 }. Under named
          parameters it might be just 42. Or maybe not. It's ambiguous.

          Because named parameters are implied in every method, it means every method has to have a little extra code to check if the first argument is a hash ref. This adds a performance hit of about 10-15% to an empty method call whether or not you use it.

          #!/usr/bin/perl -lw
          use Benchmark qw(cmpthese);
              package Methods;
              use Method::Signatures;
              method echo(\@args) {
                  return @args;
              package Subs;
              sub echo {
                  my $self = shift;
                  my $args = $_[0];
                  return @$args;
              package Subs::With;
              sub echo {
                  my $self = shift;
                  my $args = (ref $_[0] eq 'HASH') ? $_[0]->{args} : $_[0];
                  return @$args;
          cmpthese( shift || -3, {
              'M::S'              => sub { Methods->echo([1,2,3,4]) },
              'sub'               => sub { Subs->echo([1,2,3,4]) },
              'with positional'   => sub { Subs::With->echo([1,2,3,4]) },
              'as positional'     => sub { Subs::With->echo({ args => [1,2,3,4] }) },
                              Rate as positional with positional         M::S          sub
          as positional   272775/s            --            -39%         -45%         -47%
          with positional 448256/s           64%              --         -10%         -13%
          M::S            496243/s           82%             11%           --          -3%
          sub             512481/s           88%             14%           3%           --

          It needs more thought. Maybe you can think of some trick to eliminate that drag. Or maybe a method would have to declare its use of named parameters.