ns justice. Looking ahead, I do not see this state changing for
the better in the foreseeable future.
It's my hope that someone none(@Larry) can and will pick this effort up.
I will give whatever assistance I can to anyone choosing to do so. Drop
me a line.
-- Rod Adams
at does nothing:
sub Foo { }
Is it illegal to say this?
sub Foo returns Void { }
Can't we just say :
Void =:= none(Any)
and get Void for near free?
-- Rod Adams
taken from what Larry was talking about when he first brought
up the [] metaop.
Unless, of course, there is some subtle difference between a 3-d hash
and a hash of hashes of hashes that invalidates this.
-- Rod Adams
er we have
to make != and !~ and ne transform themselves via "not raising", or
we have to disallow negative comparisons on junctions entirely.
Opinions?
I go with option 2b: leave the syntax the way it is, but fire off a
warning, not an error when someone does this.
-- Rod Adams
Larry Wall wrote:
On Sat, May 14, 2005 at 12:51:32PM -0500, Rod Adams wrote:
: Unless, of course, there is some subtle difference between a 3-d hash
: and a hash of hashes of hashes that invalidates this.
No difference, I hope. The multidimensional notation is meant
to extend to HoH and AoA
e it's not
at all obvious that $x{2} is calling an array.
-- Rod Adams
eople on this list actually stand on the issue.
Here's the list as I've heard them:
$?SELF, and nothing else by default.
$_ bound to $?SELF at start of method.
o.
O.
this.
self.
me.
^
->
_
° (an idea I just had. would likely need a 7-bit option as well)
..
As for myself, I'm unfavorable to the first option, favorable to ->, °,
and me., neutral to the rest.
-- Rod Adams
Juerd wrote:
Rod Adams skribis 2005-05-14 19:21 (-0500):
o.
O.
this.
self.
me.
Not special syntax, meaning you can no longer use these identifiers for
your own class. Bad style to use single-letter identifiers, but we know
what trouble $a and $b in Perl 5 cause, and the B:: namespace.
I
easy
optimization of including unboxed equivalents and letting MMD sort it out.
-- Rod Adams
the CALLER is. Therefore, when log10() is called, the CALLER for
log() is the same as the CALLER for log10.
IMO, if this is not the case, it severely limits the utility of curried
functions. Comments from @Larry requested.
-- Rod Adams
My general thoughts has been that:
[op] @list
behaves something like:
eval join(op, @list)
so feeding it an empty list would return undef, regardless of op.
Similarly, if @list is just one element, it returns that element.
-- Rod Adams
hat way, doesn't mean it is that way.
But the "eval join" way of looking at it does seem to be consistent with
what I've seen discussed previously, and would provide a useful way to
remember the effects of edge cases.
-- Rod Adams
#x27;d have to stop and wonder if wrapping
it inside a map would be more natural. If it does happen, it'd likely
need to copy the key generation style of the new sort.
-- Rod Adams
g someone has to ask for, and that it
likely shouldn't carry the name 'uniq'.
-- Rod Adams
, assuming the module author was kind enough to up the
version number.
Glancing at S11, I see where you're coming from. There is some logic in
giving all the p5 modules an author of "perl5", since they will not have
one on their own. However, I think the calling syntax would have to be
"use Digest-(Any)-perl5;" to force the usage of a perl5 version.
-- Rod Adams
n an arrayref to an array element.
-- Rod Adams
Austin Hastings wrote:
--- Rod Adams <[EMAIL PROTECTED]> wrote:
TSa (Thomas Sandlaß) wrote:
You mean @a = [[1,2,3]]? Which is quite what you need for multi
dimensional arrays anyway @m = [[1,2],[3,4]] and here you use
of course @m[0][1] to pull out the 2. I'm not s
ize 3 in Perl6?
@a = 1,2,3;
You could, if you changed the precedence of , to be tighter than =.
However, by default, = has higher precedence than ,, so that you need
parens to override this decision: @a = (1,2,3);
Or use
@a <== 1,2,3;
-- Rod Adams
Markus Laire wrote:
Rod Adams wrote:
TSa (Thomas Sandlaß) wrote:
You mean @a = [[1,2,3]]? Which is quite what you need for multi
dimensional arrays anyway @m = [[1,2],[3,4]] and here you use
of course @m[0][1] to pull out the 2. I'm not sure if this
automatically
makes the array
r die.
In p5, your only options were to 1) not install the new version 2)
install it, and globally update your code to match, 3) give each script
it's own libpath.
I still think auto fallback makes sense. If you don't like it, always
fully specify your "use" statements. See S11 for details.
-- Rod Adams
Juerd wrote:
Rod Adams skribis 2005-05-26 4:15 (-0500):
From S02: "Array and hash variable names in scalar context
automatically produce references."
Since [...] produces a scalar arrayref, we end up with an arrayref one
both sides of the =.
No.
There is no scalar cont
wever, as I pointed out before, since in p5
there is no notion of an author URI, haveing that become the string
'perl5' makes sense, and could be matched against, both positively and
negatively.
-- Rod Adams
y be a split between bytecode/doc
distros, and full source distros.
I have no thoughts on how to handle the (un)installation of collections.
-- Rod Adams
Nathan Gray wrote:
possibly as an strftime() pattern.
Can we please make sure that strftime() is _not_ OS dependent like the
POSIX version is now?
-- Rod Adams
typed junction would look like : "Junction of Int|Str".
-- Rod Adams
to me that C should have an implied C on it's lhs.
Unless we spell that C.
-- Rod Adams
Sam Vilain wrote:
Rod Adams wrote:
How do I specify the signature of a context-sensitive function?
sub foo() returns (what?) {
return want ~~ Scalar ?? cheap_integer_result :: List_of_Sheep;
}
I suspect a typed junction would look like : "Junction of Int|Str".
, and dispatching accordingly.
3) a dispatch table of all the foo's currently in scope at the time the
reference is made.
Personally, I think #3 would be the most useful.
-- Rod Adams
eing moderately useful, I still find that only reliable way to
do automated multi-processing is to whip out Win32::Process and start a
new interpreter with special "I'm a child process" arguments.
-- Rod Adams
x" is spelled for certain. One could probably even
write a macro that auto-binds all the lexicals in the outer scope to the
current scope.
-- Rod Adams
Juerd wrote:
Still, argumentless split probably defaults to something. And ' ' is a
good thing to default to, IMO.
I like /\s+/ as a default for split better.
-- Rod Adams
1"}/;
s:g/multi (sub|method) / $1 /;
And then have a "single" still be multi, just with a MMD distance of
-Inf to everything.
-- Rod Adams
that counterintuitive. A more consistent
approach might produce
13
14
14
Don't you mean:
13
4
4
?
-- Rod Adams
o mentions that the 'goto' is implicit. I think I like the return
of a ref better, since you're not always going to want to build the
function out and store it. But the call can be hijacked, so I guess
that's okay.
-- Rod Adams
think. Also makes the info
available for more than just AUTO.* methods, which opens the door up for
all kinds of useful perversions, especially in the age of bindings and such.
I leave the definition of "something useful" to others.
-- Rod Adams
Larry Wall wrote:
On Mon, Jun 20, 2005 at 07:09:42PM -0500, Rod Adams wrote:
: S10 talks about how it is AUTOSUB vs AUTOMETH (and others), but AUTOLOAD
: is still around. S10 doesn't mention it, but I think it's been said that
: AUTOLOAD only gets called as a last resort.
Really
multi method foo#fiz (String x) {...}
$y = 42;
$obj.foo#fiz($y); # even though $y looks like a Num
$obj.foo($z); # let MMD sort it out.
It's unclear if
$obj.foo($y);
even works, or should work, even if it does.
It be no means solves all of Yuval's problems, but it would be a handy
workaround to un-multi your calls.
-- Rod Adams
David Storrs wrote:
On Jul 8, 2005, at 4:25 PM, Dave Whipp wrote:
Rod Adams wrote:
multi method foo#bar (Num x) {...}
multi method foo#fiz (String x) {...}
$y = 42;
$obj.foo#fiz($y); # even though $y looks like a Num
$obj.foo($z); # let MMD sort it out.
Instead of
At 10:05 AM 7/31/2003 -0600, Luke Palmer wrote:
Well, I don't think it's possible, actually. There's a flattening
list context at the beginning (implying a sugary drink from 7 eleven),
followed by a code block. But, as we know, slurpy arrays can only
come at the end of positional parameters.
Anyo
about.
-- Rod
Rob
-Original Message-
From: Rod Adams [mailto:[EMAIL PROTECTED]
Sent: Thursday, July 31, 2003 12:56 PM
To: Perl 6 Language
Subject: Re: Perl 6's for() signature
At 10:05 AM 7/31/2003 -0600, Luke Palmer wrote:
>Well, I don't think it's possible, actually. Th
had massively distributed mod_perl servers,
where all the code past a simple stub was stored in a central RDBMS.
Made releases and version control much nicer.
-
By saying
#!/usr/bin/perl6
forces Perl 6, I assume you mean : "The compiler sees /:i ^#! .* perl6/
on the first line".
-
-- Rod Adams
Larry Wall wrote:
On Tue, Nov 09, 2004 at 09:18:47PM -0600, Rod Adams wrote:
: Can we get an AUTOCLASS/AUTOCLASSDEF hook pair?
Considering a class is just a variable in another symbol table, seems
like an AUTOVAR in the container might cover it.
I guess I don't understand enough of how
P6REs, much to
the chagrin of those of us who parse html on a regular basis, using them
as such in the rest of P6 makes sense as well. Parsing should not be
hindered since one would occur in operator context, and the other in
expression context.
-- Rod Adams
Brent 'Dax' Royal-Gordon wrote:
I like this in general. However...
Larry Wall <[EMAIL PROTECTED]> wrote:
* Since we already stole angles from iterators, «$fh» is not
how you make iterators iterate. Instead we use $fh.fetch (or
whatever) in scalar context, and $fh.fetch or @$fh
if( $a<$b && $c<$d ) {...}
if( $a < $b && $c < $d ) {...}
In line2, my mind has to stop and ask: is that "($a < $b) && ($c < $d)",
or "$a < ($b && $c) < $d". It quickly comes to the right answer, but the
question never comes up in the first line. If I wanted to use more
parens for clarity, I'd use LISP.
-- Rod Adams
C in standard implementations.
So C and C? yeck.
-- Rod Adams
Alexey Trofimenko wrote:
On Sat, 04 Dec 2004 11:03:03 -0600, Rod Adams <[EMAIL PROTECTED]> wrote:
Okay, this rant is more about the \s<\s than \s=\s. To me, it is
easier to understand the grouping of line 1 than line 2 below:
if( $a<$b && $c<$d ) {...}
if( $a < $b &
Larry Wall wrote:
On Sat, Dec 04, 2004 at 08:14:17PM -0600, Rod Adams wrote:
: In fact, unary = imposes whitespace requirements on all ops that end in =.
Not true.
I guess not all cases. But several do in certain situations.
$x ==<$foo>; # $x == <$foo>; $x = =<$foo>;
@
Larry Wall wrote:
<>On Sat, Dec 04, 2004 at 08:55:00PM -0600, Rod Adams wrote:
: $x ==<$foo>; # $x == <$foo>; $x = =<$foo>;
: @x <==<$foo>; # @x <= =<$foo>; @x <== <$foo>;
: $x//=<$foo>; # $x // =<$foo>; $x //= <$foo>;
: [EMAI
but. For reference, I always have to do a
'perldoc perlvar' when I need a P5 $.
-- Rod Adams
Considering that "proper" and common usage, not to mention strictures,
dictates a heavy insistence on 'my'. I will thus assume that creation of
lexical variables with 'my' far out numbers the creation of package
space globals. Should we not then have it where it's the default
behavior, and crea
:
bit @bits;
int @ints;
num @nums;
int4 @nybbles;
str @buffers;
ref[Array] @ragged2d;
complex128 @longdoublecomplex;
Given that most of the stated reservations had to deal with explicit
declaration better defining scope, what is wrong with drooping the my in
this case?
-- Rod Adams
, attempting to bring less monkish fellows up
to enlightenment often encounters mental blocks. This might help, having
a different syntax makes it significantly less 'magical'. (even though
Magic is Good, imho)
I should probably stop rambling now and get some sleep.
-- Rod Adams
< each >>, except, of course,
that it deletes the pair at the same time.
If we do that, I'd also want to be able to
push %x, %y;
which would mean something like:
%x{%y.keys} <== %y{%y.keys};
but be much easier to read.
-- Rod Adams.
(And now I'm really off to bed.)
rays should be more than sufficient for
editing junctions.
-- Rod Adams
Damian Conway wrote:
Rod Adams wrote:
The overall impression I'm getting here is that we need some syntax
for saying:
$x = any(1..1000) such_that is_prime($x);
In standard Perl 6 that'd be:
$x = any(grep {is_prime $^x} 1..1000);
or, if you prefer your constraints postfixed:
$x
Patrick R. Michaud wrote:
On Sat, Feb 12, 2005 at 03:49:02AM -0600, Jonathan Scott Duff wrote:
On Sat, Feb 12, 2005 at 01:03:26AM -0600, Rod Adams wrote:
I also find the following incredibly disturbing:
perl6 -e "$x = 'cat'|'dog'; say $x;"
do
Patrick R. Michaud wrote:
On Sat, Feb 12, 2005 at 12:41:19AM -0600, Rod Adams wrote:
Of course we'll always have C. But this is Perl, and I want YAWTDI.
After all, another way to test membership was just added, whereas before
you pretty much just had C.
...another way to test membe
Patrick R. Michaud wrote:
On Sat, Feb 12, 2005 at 01:18:53PM -0600, Rod Adams wrote:
My issue is less that lists and sets are radically different. It is much
more a matter of Junctions and Scalars are radically different. Getting
me to accept that a Scalar holds several different values at once
somewhat inefficient?) is_prime test for $bar
if is_factor(none(2..sqrt($bar)), $bar) { say "$bar is prime"; }
But what happens when you try to escape the boolean context? I'll
reiterate my autothreading concerns above.
And in these, you still have to do something completely different to
determine what the factors are.
Sometimes a short loop is a good thing.
btw, in my set notation, you get:
@bar * {is_factor($^a, $foo)}
-- Rod Adams
Patrick R. Michaud wrote:
Rod Adams wrote:
I would argue that this sort of relational comparison is of limited
usefulness.
Well, except junctions hold more information than the simple comparisons
I've given here. For example, a junction can have a value like:
$x = ($a &
tion hold values of completely different types, or just
different values of the same type?
If evaluation of one value of a junction causes an error, is $! now a
junction as well?
-- Rod Adams
Damian Conway wrote:
Rod Adams wrote:
I also find the following incredibly disturbing:
>perl6 -e "$x = 'cat'|'dog'; say $x;"
dog
cat
That would be disturbing if that's what happened.
C is just a shorthand for C.
So saying a junction is the same as printing
es.
So I'm interested in hearing what pushes Arrays and Hashes over the edge
for needing their own container and sigil, whereas Junctions/Sets do not.
-- Rod Adams
Damian Conway wrote:
>Rod Adams wrote:
>
>> However, what if what you're calling a non-Perl Parrot based function?
>> Do we disable junctions from playing with non-PurePerl functions? Or do
>> we autothread over them? How do we tell if a non-Perl function outputs
&g
At 01:04 PM 2/15/2005 -0800, chromatic wrote:
On Tue, 2005-02-15 at 14:26 -0600, Rod Adams wrote:
> So I'm interested in hearing what pushes Arrays and Hashes over the edge
> for needing their own container and sigil, whereas Junctions/Sets do not.
Perl isn't a "pure" ob
e was different from yours in almost
every respect. You put limits on unsuspectedly storing a junction in a
scalar. I made a new place to put them.
-- Rod Adams
e a relatively easy way to create a
user-defined class with it's own sigil? (w/o having to modify half the
parse rules).
-- Rod Adams
Patrick R. Michaud wrote:
On Tue, Feb 15, 2005 at 03:07:53PM -0600, Rod Adams wrote:
I see it this way:
When perl sees a function call, and one of the arguments is a junction,
there are three basic options:
1) If the junction is wrapped up in some larger container, like a slurpy
list, pass it
$a,$b),any($c,$d)) == any($a,$b,$c,$d)
all($a, $a) == $a
all($a,$a,$b) == all($a,$b)
all(all($a,$b),any($c,$d)) == all($a,$b,$c,$d)
none($a, $a) == undef
none($a,$a,$b) == none($a,$b)
none(none($a,$b),none($c,$d)) == none($a,$b,$c,$d)
one($a, $a) == false
one($a,$a,$b) == ($a == $b ?? undef :: $b)
-- Rod Adams
It's just a real pain to type chars that are
not bound on your keyboard.
As for the undef's, I didn't know what else to call the empty junctive.
-- Rod Adams
implify a junction, by removing the nestedness of it,
or removing terms outright. In the process, I'm making sure that I
understand what they mean.
-- Rod Adams
e, and
each of them has a very limited number of values it can possess. Not any
noun taking on the value of any two or more other nouns at once. 2) it
is almost never in question that only one meaning was meant, and the
other meaning was merely a cover, to prevent a faux-pas.
-- Rod Adams
=$b or $x==$c or $x==$d) { ... }
The rest of the invention feels like "Magic", and is something the
experienced will tell the inexperienced not to mess with until they
really understand the consequences of using them. And even then, few of
the experienced will make more use of it than the simple case.
-- Rod Adams
Larry Wall wrote:
That, and we'd like a novice to be able to write
given $x {
when 1 | 2 | 3 {...}
when 4 | 5 | 6 {...}
}
Or just change C to accept a list of things to compare against,
followed by a coderef.
-- Rod Adams
Brent 'Dax' Royal-Gordon wrote:
Rod Adams <[EMAIL PROTECTED]> wrote:
Larry Wall wrote:
That, and we'd like a novice to be able to write
given $x {
when 1 | 2 | 3 {...}
when 4 | 5 | 6 {...}
}
Or just change C to accept a list of things to compare against,
Larry Wall wrote:
On Thu, Feb 17, 2005 at 02:18:55AM -0600, Rod Adams wrote:
: The simple if is:
:
: if $x ~~ (1,2,3,4) {...} # parens needed here since , is lower than ~~
: in precedence.
That is asking if $x is a list containing 1,2,3,4.
Quoting S04:
$_ $xType of Match
Brent 'Dax' Royal-Gordon wrote:
Rod Adams <[EMAIL PROTECTED]> wrote:
Larry Wall wrote:
Junctions can short circuit when they feel like it, and might in some
cases do a better job of picking the evaluation order than a human.
I was afraid someone was going to say that
mention, you've already defined P6 to be good at this
multi-sub/method game, so take advantage of it. It's not like this table
will be represented all in one function (at least I hope not)
-- Rod Adams
Luke Palmer wrote:
Rod Adams writes:
Junctions are intended to be used mainly within conditionals and other
statements;
If the set of these "other statements" is limited, consider creating a
Junction class (which needs a "use Junction;" to activate), which
o
Jonathan Scott Duff wrote:
On Fri, Feb 18, 2005 at 12:42:31PM -0600, Rod Adams wrote:
No, but nor does it have a concept quite like a variable.
Which significantly weakens the "mapping naturally to human linguistic
structures" argument, IMO.
Why exactly? It's ju
throw an exception. But that's likely not what this
discussion is about.
In the terms of junctions as defined, I expect that it would stop at the
lowest value of $x greater than or equal to 4. Unless we start allowing
junctive lists as well as junctive scalars...
-- Rod Adams.
gt;, I'd say that it should handle junctions being fed into it
by throwing an exception.
-- Rod Adams
Brent 'Dax' Royal-Gordon wrote:
Rod Adams <[EMAIL PROTECTED]> wrote:
Luke Palmer wrote:
2..sqrt($x)
What the hell does that mean? Do you get a junction of lists out? Or
does sqrt die because it's not expecting a junction?
What on earth does C< for (2..sqr
Brent 'Dax' Royal-Gordon wrote:
Rod Adams <[EMAIL PROTECTED]> wrote:
if $x == 3|4|5|6 {...}
would thread over infix:<==> without any funkiness, since we'll assume
operators are well written, and can take junctions as parameters, same as:
if is_prime(3|
Brent 'Dax' Royal-Gordon wrote:
Rod Adams <[EMAIL PROTECTED]> wrote:
The caller is not in a position to know if the callee is internally
structured in such a way that passing in a raw junction makes sense.
Sure
they are. It's called reading the documentation. If
Damian Conway wrote:
Rod Adams wrote:
All I want now is for autothreading to be explicit.
It already *is*.
The only way that:
is_prime($x)
can ever autothread is if $x holds a junction. But that can now only
happen if there's an explicit C in scope where $x was
assigned to (or the exp
ue to the side effects such behavior can generate. To
keep the power of junctions viable, explicit threading should be
trivially easy, but it should be explicit, none the less.
-- Rod Adams
any(1,6), all(2,5), one(3,4);
@x = @x.sort;
Does sort() carp on junctions, or is it just one of the weird things you
have to live with if you're playing with junctions?
-- Rod Adams
Damian Conway wrote:
Rod Adams wrote:
Is this new, or yet another important detail I missed along the way?
Or is this a side effect of not being able to store a Junction, and
can go away if C< use Junctions > is turned on?
Yes, it's a side-effect of the new default prohibition
Damian Conway wrote:
Rod Adams wrote:
I never want to see implicit threading. Ever.
If this is the only stumbling block, then it's easily solved.
Instead of ruining junctions by imposing all kinds of complex and
annoying hoops and hurdles (i.e. C and C), we can just offer a C pragma
The ability to join several RE's together,
into something that still acts like a single RE. Show me the equivalent
code without junctions, and then we'll compare the power of junctions.
btw, the examples above assume the ability to store a junction. So you
either have to 'use junctions;', or convince Larry to rescind that
restriction.
HTH.
-- Rod Adams
Damian Conway wrote:
Rod Adams asked:
> This sound reasonable enough?
Frankly, no. ;-)
Sorry, but your latest proposal sounds complex, multiply
special-cased, and way too much of an imposition on the programmer
(which is specifically what junctions are supposed to avoid).
Funny. I thought it
Eirik Berg Hanssen wrote:
Rod Adams <[EMAIL PROTECTED]> writes:
$re1 = /^ <-[x]>* x <-[x]>* $/; # match a string with exactly one
'x' in it.
$re2 = /^ <-[y]>* y <-[y]>* $/; # ditto 'y'
$re3 = /^ <-[z]>* z <-[z]>* $/; #
was the big
revelation I had the other night. The rest of this was the logical
consequence spawned off that single thought to make it a complete idea.
I think that overall in this process I've done the following:
- Kept the real power of Junctions intact.
- Provided fairly strong protection for newbies, without sacrificing
power.
- Kept Nasty surprises to a minimum.
- Got rid of the need for "half on" features.
- Provided back any power that the Prime Rule removed through sets and
expanded hyper ops.
-- Rod Adams
Damian Conway wrote:
Rod Adams wrote:
> The purpose of a junction is to allow for performing several tests at a
> given time, with the testing code needing no knowledge of that
junctions
> are present. While a junction can represent several values at the same
> time, such notions a
Damian Conway wrote:
Rod Adams wrote:
This is my major point of the post. In my opinion, your example of:
# Print a list of substrings...
my $substring = substr("junctions", any(1..3), any(3..6));
say $substring.values();
Is a perfect example of a place where saying:
# Print
Luke Palmer wrote:
We have discussed making equals low precedence enough to eliminate the
parentheses in the standard swap:
$x, $y = $y, $x;
$x, $y <== $y, $x;
-- Rod Adams
cratching their heads. (assuming that
doesn't trigger a warning/error). Overall, I like the protection it
provides, but dislike the extra three keystrokes it means for something
I use so often.
-- Rod Adams
We should instead have a list attribute, so we can say:
$x, $y, $z are mine! mine! mine!;
(Must be spoken like a three year old when read.)
-- Rod Adams
1 - 100 of 243 matches
Mail list logo
