Confused about checks on assignments in collections.

[matthewpersico]

At Applying a check to an array variable, it is stated (emphasis mine):

If a check is specified on an array, that check is applied to each element of the array, every time any element is modified in any way (assigned to, concatenated to, incremented, deleted, etc.)

At Applying a check to a hash variable, it is stated (emphasis mine):

If a check is specified on a hash, that check is applied to the value of each entry in the hash, [only (sic)] whenever those values are assigned.

I am confused. Why would you check all ten elements of an array if you are only assigning specific ones, yet check only the newly assigned elements in a hash? Am I reading the statements incorrectly? That array handling seems to be an awful bottleneck if I am going to recheck every element on each push, for example.

[Ovid]

@tobyink sorry, I've been busy this week and haven't gotten back to this. Can you explain what you mean by "the spec doesn't really provide a way to do it"? Contextual information for check blocks covers this, unless I've missed your meaning.

Here's a bijective hash:

# The values of the hash must remain unique...
check Bijective  :on(HASH)  ($new_value, %target)  {
    return $target{old} eq $new_value
           || not grep { $_ eq $new_value} } values $target{var}->%*;
}

[tobyink]

You are right, that is covered. my %numbers :of(NUM) only constrains each value in the hash, but yeah, with the contextual information it should be possible to add constraints for the whole hash.

[zmughal]

@happy-barney, is this the kind of issue you were talking about re: performance here? That the values (rather than just the variables) should have some idea of what checks they pass?

[happy-barney]

it is related by my primary concern was about passing unmodified values here and there:

my $foo :contract(x) = $value;
my $bar :contract(x) = $foo;
my $baz :contract(x) = $baz;

this problem will benefit from that solution but detailed specification will be needed

[Ovid]

@matthewpersico Sorry, that section of the spec needs to be reworded.

If a check is specified on an array, that check is applied to each new or modified element of the array, every time any element is modified in any way (assigned to, concatenated to, incremented, deleted, etc.)

It's not "all elements", it's only the elements being changed.

[Ovid]

@matthewpersico Also, the spec is now at the wiki where it can be updated. I'll make the change for this. That gist is now there for historical reasons.

[Ovid]

Are we good? Can I close this discussion now, or is there more work needed here?