No, but what's the point to allow overwriting an alias for references without throwing an error?

Should they be treated differently than 42, undef and "str", and if so, why?

Again, I'm talking about the container, not the mutable content.

Having had a further look at your OP, you seem to be complaining that the scalar ref value should readonly - I was thinking that you were wanting the anonymous array to readonly?

So is the following a correct summary of your position as to how you would like things to work?

[ 1, 2, 3];  # a readonly temporary reference to a mutable anonymous a
+rray
[ 1, 2, $x]; # also a readonly temporary reference to a mutable anonym
+ous array

bless 'Foo', [1,2,3];# a readonly temporary reference to a mutable ano
+nymous array
                     # where the array was mutated by blessing it

$a = [1, 2, 3]; # $a is a rw copy of the temp ro array reference
[download]

Dave.

My complaint is primarily about aliases, where I don't understand why Perl complains about when overwriting an alias to 1 but not one to [ 1,2,3,$x] (see examples in my OP especially the update)

Both are literal constructs unbound to any named variable.

I'm NOT saying that anonymous arrays -ie the content - should be immutable, but their reference.

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

> So is the following a correct summary of your position as to how you would like things to work?

after rereading it, yes this follows my mental model.

Analog to

1;         # a readonly temporary scalar
$a =  1 ;  # $a is a rw copy of the temp scalar
[download]

Of course I could be wrong, but I'm still waiting for someone to understand my question...

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

Perlglossary

literal

A token in a programming language, such as a number or string, that gives you an actual value instead of merely representing possible values as a variable does.

anonymous

Used to describe a referent that is not directly accessible through a named variable. Such a referent must be indirectly accessible through at least one hard reference. When the last hard reference goes away, the anonymous referent is destroyed without pity

Which of the following do you regard as a literal array:

[]
[1,2,3]
[1,2,$x]
[download]

I regard none of them as literal. [] {} are constructors; they are just syntactic sugar for a function which takes a list and returns a reference to an anonymous aggregate, e.g.

[1,2,3]
# is the same as
anon_array(1,2,3);
sub anon_array { my @a = @_; \@a }
[download]

Dave.

They are all literal reference constructors the content is mutable.

Please compare the analogue situation in JS where [] and {} explicitly documented as "literal".°

See also Readonly which makes the explicit distinction about overwriting a variable holding an array and protecting the deep content.

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

UPDATE

°)

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/Array

Arrays can be created using the literal notation:

let fruits = ['Apple', 'Banana'];

console.log(fruits.length); // 2
console.log(fruits[0]);     // "Apple"
[download]