Author: lwall Date: 2009-03-19 19:13:13 +0100 (Thu, 19 Mar 2009) New Revision: 25908

Modified: docs/Perl6/Spec/S12-objects.pod Log: [S12] attempt to clarify type narrowness of multiple constraints, enums, and where clauses Modified: docs/Perl6/Spec/S12-objects.pod =================================================================== --- docs/Perl6/Spec/S12-objects.pod 2009-03-19 13:29:43 UTC (rev 25907) +++ docs/Perl6/Spec/S12-objects.pod 2009-03-19 18:13:13 UTC (rev 25908) @@ -12,9 +12,9 @@ Maintainer: Larry Wall <la...@wall.org> Date: 27 Oct 2004 - Last Modified: 14 Mar 2009 + Last Modified: 19 Mar 2009 Number: 12 - Version: 77 + Version: 78 =head1 Overview @@ -1308,7 +1308,7 @@ You can leave out the block when matching against a literal value of some kind: - multi sub fib ($n where 0|1) { return $n } + multi sub fib (Int $n where 0|1) { return $n } multi sub fib (Int $n) { return fib($n-1) + fib($n-2) } In fact, you can leave out the 'where' declaration altogether: @@ -1335,6 +1335,111 @@ preferred if the constraint matches, and otherwise the second is preferred. +More generally, a parameter can have a set of constraints, and +the set of constraints defines the formal type of the parameter, +as visible to the signature. (No one constraint is priviledged as +the storage type of the actual argument, unless it is a native type.) +All constraints considered in type narrowness. +That is, these are equivalently narrow: + + Foo Bar @x + Bar Foo @x + +The constraint implied by the sigil also counts as part of the official type. + +Static C<where> clauses also count as part of the official type. +A C<where> clause is considered static if it can be applied to +the types to the left of it at compile time to produce a known finite set +of values. For instance, a subset of an enum type is a static set +of values. Hence + + Day $d where 'Mon'..'Fri' + +is considered equivalent to + + subset Weekday of Day where 'Mon'..'Fri'; + Weekday $d + +Types mentioned in a dynamic C<where> class are not considered part of the official +type, except insofar as the type includes the notion: "is also constrained +by a dynamic C<where> clause", which narrows it by epsilon over the equivalent +type without a C<where> clause. + + Foo Bar @x # type is Foo & Bar & Positional + Foo Bar @x where Baz # slightly tighter than Foo Bar Positional + +The set of constraints for a parameter creates a subset type that implies +some set of allowed values for the parameter. The set of allowed values +may or may not be determinable at compile time. When the set of allowed +values is determinable at compile time, we call it a static subtype. + +Type constraints that resolve to a static subtype (that is, with a +fixed set of elements knowable (if not known) at compile time) are +considered to be narrower than type constraints that involve run-time +calculation, or are otherwise intractable at compile time. +Note that all values such as 0 or "foo" are considered +singleton static subtypes. Singleton values are considered narrower +than a subtype with multiple values, even if the subtype contains +the value in question. This is because, for enumerable types, type +narrowness is defined by doing set theory on the set of enumerated values. + +So assuming: + + my enum Day ['Sun','Mon','Tue','Wed','Thu','Fri','Sat']; + subset Weekday of Day where 'Mon' .. 'Fri'; # considered static + subset Today of Day where *.today; + +we have the following pecking order: + + Parameter # Set of possible values + ========= ======================== + Int $n # Int + + Int $n where Today # Int plus dynamic where + Int $n where 1 <= * <= 5 # Int plus dynamic where + + Day $n # 0..6 + + Day $n where Today # 0..6 plus dynamic where + + Day $n where 1 <= * <= 5 # 1..5 + Int $n where Weekday # 1..5 + Day $n where Weekday # 1..5 + Weekday $n # 1..5 + + Tue # 2 + +Note the difference between: + + Int $n where 1 <= * <= 5 # Int plus dynamic where + Day $n where 1 <= * <= 5 # 1..5 + +The first C<where> is considered dynamic not because of the nature +of the comparsons but because C<Int> is not finitely enumerable. +Our C<Weekday> subset type can calculate the set membership at compile +time because it is based on the C<Day> enum, and hence is considered +static despite the use of a C<where>. Had we based C<Weekday> on +C<Int> it would have been considered dynamic. Note, however, that +with "anded" constraints, any enum type governs looser types, so + + Int Day $n where 1 <= * <= 5 + +is considered static, since C<Day> is an enum, and cuts down the +search space. + +The basic principle we're trying to get at is this: in comparing +two parameter types, the narrowness is determined by the subset +relationships on the sets of possible values, not on the names of +constraints, or the method by which those constraints are specified. +For practical reasons, we limit our subset knowledge to what can be +easily known at compile time, and consider the presence of one or +more dynamic constraints to be epsilon narrower than the same set of +possible values without a dynamic constraint. + +As a first approximation for 6.0.0, subsets of enums are static, +and other subsets are dynamic. We may refine this in subsequent +versions of Perl. + =head1 Enums An enum is a low-level class that can function as a role or property.