I think we are saying much the same thing, but quibbling over terms :) I'd only note that there is a difference between "useful" and "usability".

I like the "raw parse trees" description of LISP. I'd never really thought of it that way, but it is a very accurate description from my less than comprehensive knowledge of the language. I assume that there is some mechanism for code re-use in LISP? Even if it is only something like include files? I also have no idea how you would read/write a file in LISP. I keep meaning to get around to installing a build of Scheme and playing.

P6 is definitely doing some things to orthoganise the language--consistant use of $, @, % comes to mind--but there are other areas where calls for orthoganality have been rejected. The most obvious example I can think of is length. I don't think that we are likely to see

my $sizeOfArray = @array.length;
[download]

my $sizeOfArray = length @array;
[download]

 
my $lenOfString = scalar @$scalar;
[download]

So, whilst P6 is regularising the language in many places, it's being done not for sake of orthoganality itself, but to simply the use of the language. If it also makes it more elegant, thats great, but I don't think that is the primary drive for change.

Let me add, I think that Perl 5 can be elegant. Some of Abigail's recursive solutions are extremely elegant. Likewise some of your code. But as you've noted about some of my P5 in the past, it's also possible to produce stuff which is "Yuck!":)

As for C++. I've fairly recently discovered a language that I think achieves most of what C++ set out to achieve (except backwards compatibility), but that does it with much less complexity. It's still evolving, and I haven't had opportunity to make a great deal of use of it in larger programs yet, but the simplicity of its objects, the automatic memory management, built-in associative arrays endear me to it strongly.

The fact that I can still get down and dirty with the machine as with C, but have a few more HLL features to simplify things, plus the compiled-to-native performance make it really interesting to me.

In fact, you're not even going to see

    my $sizeofstring = length($string);
[download]

That's because "length" has been deemed to be an insufficiently specified concept, because it doesn't specify the units. Instead, if you want the length of something in characters you use

    my $sizeinchars = chars($string);
[download]

and if you want the size in elements, you use

    my $sizeinelems = elems(@array);
[download]

This is more orthogonal in some ways, insofar as you can now ask for the size in chars of an array, and it will add up all the lengths of the strings in it for you:

    my $sizeinchars = chars(@array);
[download]

And if you ask for the number of elems of a scalar, it knows to dereference it:

    my $ref = [1,2,3];
    my $sizeinelems = elems($ref);
[download]

These are, in fact, just generic object methods:

    @array.elems
    $string.chars
    @array.chars
    $ref.elems
[download]

And the functional forms are just method calls in disguise.

So maybe length() is a bad example now. Sorry. :-)

By the way, you can also use %hash.elems, which returns the number of pairs in the hash. I don't think %hash.chars is terribly useful, but it will tell you how many characters total there are in both keys and values.

Actually, the meaning of .chars varies depending on your current level of Unicode support. To be more specific, there's also:

    $string.bytes
    $string.codepoints
    $string.graphemes
    $string.letters
[download]

...none of which should be confused with:

    $string.columns
[download]

or its evil twin:

    $string.pixels
[download]

Better & better.

Presumably my elems = $nonrefscalar.elems; is just an error?

Do you need the parens for the functional form or can you do my $noffchars = chars $scalar:;

---

Examine what is said, not who speaks.

"Efficiency is intelligent laziness." -David Dunham
"Think for yourself!" - Abigail

(Note: I knew about the method call syntax and was going to mention it — but Larry did, so I don't have to. As is the case with many things. Thanks, Larry!)

Perl6 is going for more orthogonality than you may have been thinking. We're not going to get @array.length exactly, but a rose by any other name (@array.elems), well…

Makeshifts last the longest.