use Perl

• Launch from Moonbase Alpha (Score:1)

  by jplindstrom (594)

  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?
  • Re: (Score:2)

    by schwern (1528)

    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
    • Re: (Score:1)

      by jplindstrom (594)

      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*
      • Re:Launch from Moonbase Alpha (Score:2)

        by schwern (1528) on 2008.09.23 4:42 (#65090) Homepage Journal

        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 [perlcabal.org] 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] }) },
        });
        __END__
                            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.

        Reply to This

        Parent