Having you been reading what I've written? Or just picking out random phrases and responding to those. You have stopped trying to address the issues...and I am tired of repeating myself.

Lvalue subs as defined in P5 have--by the overwelming judgement of the opinions expressed on this site--fundemental issues with validation.

Type validation is no answer. You cannot replace everything you can do with:

die 'Bad value!'
    unless substr( $attr, $_[1], $_[2] ) =~ $regex;
[download]

with a type definition. Nor with a tie, because those parameters will not be available to it. Nor with a trait for the same reasons.

The only mechanism offered to correct this in P6 does not adaquately address those issues. Without some change to the muted solutions, the same problems will become enshrined forever in the trap of backwards compatibility.

They could be addressed now, before that comes to pass. But, if everyone buries their head in the sand saying "Larry's always right"--then they are ignoring history.

Please show me which parameters you need access to.

#!/usr/bin/perl
use strict;
use warnings;

package UglyTie;
use Data::Dumper;

sub TIESCALAR {
    my $class = shift;
    bless [ @_ ], $class;
}

sub STORE {
    warn Dumper @_;
}

sub FETCH {
    warn Dumper @_;
    1;
}

package main;
sub lv : lvalue {
    tie my $response, 'UglyTie', @_;
    $response;
}

lv( "foobarbazquux" x 2, 10, 5 ) =~ /whatever/;
[download]

Makeshifts last the longest.

Your sample code does not address the problem.

The arguments are those passed to the lvalue sub that define what lvalue is returned by the sub, and therefore what gets modified by the assignment.

In order to validate that part of the data that was modified, you need to know those arguments. So, show me how you can avail the FETCH and STORE methods of the tie of those arguments, so that they can achieve the same validation as is shown in the commented out code in the sub modifySubstring()?

#!/usr/bin/perl
use strict;
use warnings;

package UglyTie;
use Data::Dumper;

sub TIESCALAR {
    my $class = shift;
    bless [ @_ ], $class;
}

sub STORE {
    warn Dumper @_;
}

sub FETCH {
    warn Dumper @_;
    1;
}
package SillyClass;

sub new {
    bless \$_[ 1 ], $_[ 0 ];
}

sub modifySubstring: lvalue {
    my( $self, $start, $length ) = @_;
    substr( $$self, $start, $length );

      ## Validate that part of the string that was modified
    # die 'Bad value' 
    #    unless substr( $$self, $start, $length ) =~ m[^[a-z]+$];
}

1;

package main;

my $silly = SillyClass->new( 'a teststring' );
$silly->modifySubstring( 3, 3 ) = 'ABC';
[download]

Same problem here. How can I perform the validation of the values assigned to the slice, as shown commented out, through a tie, or traits, or a type definition?

#!/usr/bin/perl
use strict;
use warnings;

package SillyClass2;

sub new {
    my $class = shift;
    bless \@_, $class;
}

sub modifySubset: lvalue {
    my( $self, $start, $end ) = @_;
    
    @{ $self }[ $start .. $end ]
    
    ## Validate that all values in the slice being assigned are
    ## non-zero, even and uniq

    # my %uniq;
    # die 'Bad value' 
    #    unless $end - $start == grep{ 
    #    $_ && !( $_ & 1 ) && not ++$seen{ $_ } 
    #} @{ $self }[ $start .. $end ];
}

1;

package main;

my $silly = SillyClass2->new( map $_ * 2, 1 .. 50 );
$silly->modifySubset( 15, 35 ) = ( 1 .. 20 ); ## should cause an error
+!
[download]

---

Examine what is said, not who speaks.

Silence betokens consent.

Love the truth but pardon error.