draegtun

The article doesn't mention Perl at all but it did have some direct influences on Ruby.

Even Ruby's trailing blocks syntax are an homage to Perl's block list subroutines:

  # first Ruby example in article
  users.select { |u| u.admin? }.map(&:email)

  # using Perl's block list
  map {$_->email} grep {$_->is_admin} @users;

Yes (de)referencing can be a PITA sometimes but you've probably forgotten that your example code could have been better written like this:

    $hash1->{key1}{key2}

And if `hash1` was a hash (instead of a hashref) then it's just this:

    $hash1{key1}{key2}

The `%{}` de-reference you mention later is only when you have an operation that requires a hash, for eg:

    keys %{$hash1{key1}}

And for kstrauser example later in Python...

    hash1["hash_name"]["array_name"][3]

the equivalent in Perl would be...

    $hash1{hash_name}{array_name}[3]

I find having {} & [] as lookup keys for their types is not only more explicit but also safer/correct.

Except in homoiconic languages, like Rebol/Red/Lisp, there is no (need for a) new syntax.

You can do this in...

  # perl
  my $x = do {
     …
     5
  };

  ;; Rebol/Red
  x: do [
     …
     5
  ]

>> It really should be a few lines of code to add an “unless(X) {}” statement to “if(!X) ()” to...

Or even one line :)

Factor...

  : unless ( ? quot -- res ) swap [ drop ] [ call ] if ; inline

Rebol/Red...

  unless: func [expr block] [either expr [] block]

>> People pretends Smalltalk doesn't exist?

And Factor and many implementations of Lisp too!