HaloO, Luke Palmer wrote:
Junctions are frightfully more abstract than that. They only take on meaning when you evaluate them in boolean context. Before that, they represent only a potential to become a boolean test.
This is very well spoken err written---except that I would use beautifully there :) Well, and their meaning is sort of reduced to one(0,1) in boolean context. It does not originate there ;) So junctions are mean outside boolean context :)) BTW, is 'the means' just the plural of 'the mean' or are these two completely unrelated substantives? E.g. does one say 'a means' with 'means' beeing a singular noun? How about the type Mean or Means as supertype of the four junction types? For example contrasting them with Plain values? So, to support the four junction generators the compiler has to decide at a boolean node of the AST if the subtree originating there could possibly be junctive and prepare the code for it! If there is no proof or disproof, this decision must be deferred to runtime when the actual data---that is the involved parties not their types---are available. OTOH, the programmer might short-cut very easily with a 'no junctions' in the scope. BTW, does that imply that junctions fall back to list behaviour when it comes to evaluating the node? How does this lexical pragma traverse the dynamic scopes at runtime? In other words how do junctive and non-junctive parts of a program interact? Once again this boosts my believe that junctions should travel in code vars. E.g. my &test = any(1,2,3).assuming:op<==>; my $x = 3; if $x.test {???} Also the typeish aspects of first class closures is somewhat under-represented in Perl6---or I don't see it. What should e.g. the following my $sci := (&sin == &cos); # intersectons of sin and cos put into the var? I think it is a lazy list(ref), an iterator or generator or simply a calculated code object(ref) with type :(Ref of List of Num where {sin == cos}). In other words @sci = pi/4 »+« pi »*« (-Inf..+Inf); # :(Array of List ...) where I would like the last thing beeing written (-Inf,,+Inf) or (-Inf,,,). Actually it is the Int type as list, set or any. With real ranges it might be (-Inf..+Inf):by(pi) or so. To summarize: I propose to unify the invocations of junctions with embedded closure calls in general. Of these Perl6 has got many: there are pipes, lazy lists, slices, control structures, sorting, key extraction, ... --