A Review of Perl 6

Subpar performance is a huge drawback of Perl 6.

I usually don't program in Perl, but occasionally use it instead of sed.

Compare, Perl 5 vs. Perl 6:

    $ time yes | head -n1000000 | perl -pe 's/y/n/' >/dev/null

    real	0m0.945s
    user	0m0.944s
    sys	0m0.016s
    $ time yes | head -n1000000 | perl6 -pe 's/y/n/' >/dev/null

    real	2m49.881s
    user	2m44.892s
    sys	0m2.184s

Spending several minutes to do what can be done in under 1 second is just unacceptable.

I found this a nifty intro to perl6. I am a 70 year old retiree and have 37 years of C programming and some C++, perl5, and other languages. This is the first time I've been able to make the slightest headway digging perl6.

A lot of people here seems to think there is a lot of potential for perl6, with the only complaints being the name and its speed, with at least speed expected to improve.

But I thought this review sounded pretty damning.

Numerical operations are opaque as you never quite know if it's a rational or a float.

The grammar engine is inferior to other languages 3rd party modules, hard to debug and seems to not be suitable for its main purpose (parsing perl6!)

Everything seems to be writable in a multitude of ways with no clear indication if these ways are functionally different.

I do a lot of NLP in python and I wish for better tools to munge and clean up my text data, and have been curious about perl6, but after reading this review I don't find Perl all that enticing at all.

This is an interesting article overall, but I'm unsure what this part is trying to say:

> Perl 6 is aware of graphemes and combining codepoints, and unlike Python, Swift, or Elixir, Perl 6 can can access arbitrary graphemes by position in constant time, rather than iterating over every grapheme to access a particular one. [...] Graphemes are stored internally as 32-bit integers; this address space is large enough to contain all legal codepoint combinations

It sounds like Perl6 is simply storing strings as UTF-32. AFAIK, there's nothing called a "grapheme" in Unicode; the closest I know of are "grapheme clusters", which are theoretically unbounded in size and so cannot simply be stored in a 32-bit integer. Maybe by "grapheme" the author means "Unicode scalar value"? But being able to access those in constant time isn't especially useful, AFAIK.

> ... but I personally prefer to be treated like a responsible adult rather than, for instance, a teenager trapped in the father-knows-best house of Go.

My feelings exactly.

Its been endlessly stated but naming it 'Perl 6' was a huge mistake. Perl 5 has an enduring reputation for crufty, unmaintainable code written by graybeard sysadmins. I wrote a lot myself that I wouldn't want to ever deal with again. I think they would have benefitted from a clean break from a marketing perspective, especially considering it's completely different.

If you want good error reporting from grammars then you really need to implement a FAILGOAL in the grammar. For example:

  method FAILGOAL($goal) { die "cannot find $goal near position {self.pos}" }

There is also a very helpful grammar tracer and debugger when developing a grammar:

  use Grammar::Tracer;

or

  use Grammar::Debugger;

https://github.com/jnthn/grammar-debugger

Perl6 feels like it could be the ultimate language for Man, Machine, Mineral, and Beast, if only we could teleport into a parallel universe where it war already in widespread usage. The sense of sheer potential off the language is intoxicating.

I like to imagine the Geth in Mass Effect run on a hybrid Perl6/Erlang platform.

  $ perl6
  To exit type 'exit' or '^D'
  > 0.3 == 3e-1
  False

I'm really really not sure how I feel about this. Does anyone know why the decision was made to make exponential notation return a float while decimal notation returns a rational?

I'm a bit disappointed about grammars. Usually, when I try to use them, it gets difficult. Especially when recursion is involved. Lately, for instance, I was reading the ECMAScript 2016 reference, and in it they define a repetition of elements with recursion[1]:

    ArgumentList:
        AssignmentExpression
        ArgumentList , AssignmentExpression

I've never managed to do something like that with Perl 6's grammar. Basically every time I try to use recursion, it doesn't quite work unless I do some tricks.

Maybe I ask too much, I don't know.

1. http://www.ecma-international.org/ecma-262/7.0/index.html#se...

Superb; enjoyable write up. Very witty in parts, no puns in sight. Makes me want to try Perl6 out.

> Modifiers (i for case-insenstive is the most important one) can appear inside a regex when preceded by a colon. For example, this Perl 5 regex:

> (Male|Female) (?:[Cc][Aa][Tt]|[Dd][Oo][Gg])

> would be translated to Perl 6 as:

> (Male || Female) ' ' [:i cat || dog]

Perl 5 does support this feature:

(Male|Female) ((?i)cat|dog)

or:

(Male|Female) (?i:cat|dog)

FWIW, I note my own trigger for revisiting Perl 6, is the existence of a standards-compliant transliterating implementation of another language, say Javascript, written in Perl 6. No ambiguity, just "does it pass the validation suite?", and "how fast is it?". A decade of "it's usable now!" has left that sentence with little signal weight for me.

The idea is, at least as of a decade ago, it was straightforward to massage the then ECMA spec into Perl 6 code. The spec says "Go to step 4 ... 4. ..."? Well, "goto Step_4;... Step_4: ..." is code. And so on. Perl 6, at least as envisioned then, is a very nice language for language implementation. Implementation often goes like this: most of the language is easy, nicely compatible with the target; some of it is hard, requiring some struggle to impedance match; and tiny bit of it is impossible, or nearly so, or requires rewriting all the rest, because of "gotcha" conflicts with the target semantics. With a rich kitchen-sink target, almost everything becomes easier, and there's likely some hook you can use to get that impossible bit done. And when writing a compiler, (then, almost) general grammars, and multiple dispatch with type sets, is a nice place to be.

But the corollary is, when I don't see a compliant ES2017 transliterated to Perl 6, then I assume something is wrong - something isn't working yet - be it unfortunate spec, or "doesn't quite work yet at scale" implementation, or community.

The "whatever star" seems like a less-well-implemented version of Wolfram Language's pure anonymous functions:

http://www.wolfram.com/language/elementary-introduction/2nd-...

Essentially, WL uses # instead of * and requires a "&" to indicate when you're done defining your function. So the WL equivalent to Perl's

    (1, 2, 3).map: * * 2 

is

    Map[ #*2&, {1,2,3}] 

(idiomatically you would use /@ as shorthand for Map[], so it would be)

    #*2&/@{1,2,3}

Except WL is far more general with what you can do with #, and you can do things like this:

    Outer[ #1 * #2 &, {1,2,3}, {4,5,6}]

which returns

    {{4, 5, 6}, {8, 10, 12}, {12, 15, 18}}

because #1 * #2 & defines a function of two arguments, and "Outer" feeds the lists into that function. You can even use ## to refer to all the arguments passed into that function (regardless of how many arguments there are), so

    Outer[## &, {1, 2, 3}, {4, 5, 6}]

returns

    {{1, 4, 1, 5, 1, 6}, {2, 4, 2, 5, 2, 6}, {3, 4, 3, 5, 3, 6}}

And you can even do stuff like:

    f[x_] := x^2
    Outer[ #1[#2] &, {e, f, g}, {4, 5, 6}]

to get

    {{e[4], e[5], e[6]}, {16, 25, 36}, {g[4], g[5], g[6]}}

To what extent is Perl 6 now stable? I was at a LISA conference in December 2011, and watched Tobias Oetiker present the wonders of Perl 6, and though I loved what I saw, something more than a tenth of his examples broke because of recent revisions, whether semantic or to implementation. God bless the language explorers, but my takeaway was "not yet". Is now the time?

    ｢Man is amazing, but he is not a masterpiece｣

Is different than the other two, it can be thought of as short for

    Q ｢Man is amazing, but he is not a masterpiece｣

While the others are short for

    qq “Man is amazing, but he is not a masterpiece”

Which is short for

    Q :qq “Man is amazing, but he is not a masterpiece”
    Q :double “Man is amazing, but he is not a masterpiece”

Which is also short for

    Q :s :a :h :f :b :c “Man is amazing, but he is not a masterpiece”
    Q :scalar :array :hash :function :backslash :closure “Man is amazing, but he is not a masterpiece”

For more information see the [Quoting Constructs](https://docs.perl6.org/language/quoting) documentation.

---

There are modules for [debugging and tracing](https://github.com/jnthn/grammar-debugger) Grammars.

A regex is just a special kind of method by the way.

    say Regex.^mro;
    # ((Regex) (Method) (Routine) (Block) (Code) (Any) (Mu))

Which is part of the reason it doesn't have some of the niceties of parser generators built-in yet. The main reason is it got to a working state, then other features needed more designing at that point.

---

    # Perl 5
    /(Male|Female) (?:[Cc][Aa][Tt]|[Dd][Oo][Gg])/
    # is better written as
    /(Male|Female) (?i:cat|dog)/

In Perl 6 you can turn on and off sigspace mode

    /:s (:!s Male | Female ) [:!s:i cat | dog ]/
    # or fully spelled out
    /:sigspace (:!sigspace Male | Female ) [:!sigspace :ignorecase cat | dog ]/

    # or just use spaces more sparingly
    /:s ( Male| Female) [:i cat| dog]/

Note that in this case it is more like

    /( Male | Female ) \s+ [:i cat | dog ]/

In other contexts it could be slightly different. Basically it ignores insignificant whitespace.

Note that `( a || b )` is more like the Perl 5 behaviour, but `( a | b )` tries both in parallel with longest literal match.

Regular expressions are also the reason `:35minutes` is in the language by the way

    say 'a ab abc' ~~ m:3rd/ \S+ /;
    # ｢abc｣

Rather than make it a special syntax, it was generalized so it can be used everywhere.

---

The asterix in a Term position turns into a Whatever, when that is part of an expression it turns into a positional parameter of a WhateverCode.

    $deck.pick(*); # randomized deck of cards
    $deck.pick(Whatever.new); # ditto

    $dice.roll(*); # infinite list of random rolls of a die
    $dice.roll(Whatever.new); # ditto

    %a.sort( *.value ); # sort the Pairs by value (rather than key then value)
    %a.sort( -> $_ { .value } ); # ditto

Note that the last asterix was part of an expression, while the others weren't.

    my &shuffle = *.pick(*); # only the first * represents a parameter to the lambda
                             # the other is an argument to the pick method

The main reason I think for its addition to the language is for indexing in an array

    @a[ * - 1 ];

Rather than make it a special syntax exclusively for index operations, it was made a general lambda creation syntax.

I will agree that it takes some getting used to, but it is not intractable. WhateverCode lambdas should also only be used for very short code, as it can get difficult to understand in a hurry.

---

A `$_` inside of `{ }` creates a bare block lambda, basically this removes the specialness of Perl 5's `grep` and `map` keywords.

There is a similar feature of placeholder parameters `{ $^a <=> $^b }` to remove the specialness of Perl 5's `sort` keyword.

Another feature is pointy block, which removes the specialness of a `for` loop iterator value syntax.

    # Perl 5 (this is the only place where this is valid)
    for my $line (<>) { say $line }

    # Perl 6
    for lines() -> $line { say $line }

    # not special
    lines().map( -> $line { say $line } );

    # really not special
    if $a.method-call -> $result { say $result }

---

There is more to NativeCall that you haven't discovered yet.

For example, you can directly declare an external C function as a method in a class, and expose it with a different name. (if the first parameter is the instance)

Also it doesn't matter what you put in the code block for a NativeCall sub, as long as it parses. That is why it doesn't matter if you put a Whatever star (asterix) there or a stub-code ellipsis `...` in it. (you can also leave it empty)

    use NativeCall;
    sub double ( --> size_t ) is native() is symbol<fork> { say 'Hello World' }

    say double;
    say '$*PID == ',$*PID;
    # 1555
    # 0
    # $*PID == 1552
    # $*PID == 1555

---

Supplies can be pattern matched, just use `grep` on them as if they were a list. It in turn returns a Supply. You can also call `map`, `first`, `head`, and `tail` on them. Basically every List method is also on a Supply, along with special methods like `delayed`.

---

A lot about what you talked about with lists, and itemization is something that does take some time to get used to. It does get easier, but is always something you have to be cognizant of. Sort of like returning lists from subroutines are from Perl 5. It allows control over flattening that isn't available in Perl 5.

Are there any good examples of projects like this that drag on for an eternity and somehow, despite the odds, release, and also become extremely successful? It seems like after a certain point you have basically missed the boat on delivering value based on the assumptions you had when starting the project.

Lately, I've been seeing more pots on Perl. Is it just confirmation bias? or is Perl making a comeback?

> Perl 6 has Perl’s regexes with a few changes: extending the Unicode support, moving the modifiers around, and reassigning some symbols, and also changing the whitespace rules to be more legible.

So… Perl 6… has Perl-incompatible regular expressions?? Amazing.

This line from the article best summarizes it for me:

Perl 6: The Ruby on Rails of command-line tools.

As a general comment, I would love to see more "reviews" of programming languages like this, even ones that are already in, use but maybe only in one niche, or should perhaps be more popular than they are.

This reads like a literary review. I like the style a lot!

How's the toolset on Windows? Last time I checked, there were no out-of-the-box IDEs that supported debugging for Perl 6.

Excellent, thanks.

It is not a review. It is an introduction or tutorial.