Making the var read-only won't prevent concatenation or addition, so it doesn't matter that $x . [] or $x + [] doesn't make sense.^[1]. This isn't relevant to the topic at hand.

The only thing making it read-only will do is prevent assignment, and map { $_ = 3 } $x.$y makes no more sense than map { $_ = 3 } [].

Either prevent both of them, or prevent neither of them. No need for baseless inconsistencies.

1. That said, $ref+0 makes some sense for refs to things other than objects with overloads, and both concatenation and addition make sense for refs to objects with overloads (which aren't farfetched at all!)

Note that assigning to certain "unassigned scalars" is legitimate, such as the one returned by substr. Unassigned scalars with set magic simply wouldn't be made read-only, of course.

But you know what else wouldn't be made read-only? "Unassigned scalars" from XS code. Making unassigned scalar *created by Perl* read-only would create inconsistencies with those created by XS code. This reduces the benefits of making any change.

My point is about potential problems in backwards compatibility.

A transformation of a string or a number into another string or number is common, BUT the transformation of refs is impossible.

Hence it's far more likely that legacy code will break if something like $_++ became illegal for an aliased input like 3+4 .

Same code for refs wouldn't make sense at all.

I can't come up with more intuitive examples, but I'm sure those exist.

Cheers Rolf
_{(addicted to the Perl Programming Language :)
Wikisyntax for the Monastery}

Put differently, you want to prevent transformation of references, but using a completely ineffective tool to achieve it. Making references read-only doesn't prevent transformation.

Preventing transformation (stringification, numification, but not booleanification) of references might be a good idea.

Issues:

• Intentional uses of $ref+0 would have to be replaced by refaddr($ref).
• Intentional uses of "$ref" would have to be replaced.
• Programs that mostly function will start dying instead.

Benefits:

• Catch some bad code (But what code wouldn't already be obviously wrong?)

Since making the scalar read-only doesn't prevent transformation (only assignment), there is no backwards compatibility issue relating to transformation.

Hence it's far more likely that legacy code will break if something like $_++ became illegal for an aliased input like 3+4 .

And that's exactly what the change is suppose to prevent. What's the point of making the change if it doesn't prevent exactly what it's suppose to be preventing!

If you say there's no point in preventing $_ = ... when $_ is an unassigned string, then there's no point in preventing it when it's an unassigned reference.