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.
-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. There's a flattening
list context at the beginning
the language to loose the internal cohesiveness that
all languages need, and am suitably scared of design by committee... but
I'd like to think that there's something that could be done to help matters.
Comments?
Suggestions?
-- Rod Adams
PS -- I'm willing to commit several hrs a week to the effort.
At 10:40 PM 11/14/2003 -0800, chromatic wrote:
I'd really like to see people start turning the existing design
documents into story cards and programmer tests for Perl 6. That'll
make it much easier to implement the thing.
So basically go back through the existing Apoc/Exeg's and break it down
Luke Palmer wrote:
Joe Gottman writes:
- Original Message -
From: Jonathan Lang [EMAIL PROTECTED]
To: [EMAIL PROTECTED]
Sent: Saturday, December 20, 2003 3:41 PM
Subject: [perl] Re: Object Order of Precedence (Was: Vocabulary)
Larry Wall wrote:
If DangerousPet doesn't define a feed
Luke Palmer wrote:
Austin Hastings writes:
I think you guys may be talking at cross purposes. Robin, I think, is
talking primarily about coding, while Damian talks of reading.
Perhaps Damian's solution is a Unicode2Ascii perl script that emits formal
names, combined with the implementation in
Austin Hastings wrote:
From: Rod Adams [mailto:[EMAIL PROTECTED]
Question in all this: What does one do when they have to _debug_ some
code that was written with these lovely Unicode ops, all while stuck in
an ASCII world?
That's why I suggested a standard script for Unicode2Ascii
Here's my stab at a sort syntax, pulling syntax over from REs:
@out
== sort key:ri($_-[2]), key:s($_-[4])
== @in;
Basicly, you have a list of RE syntax like Ckey values, whilch take
various modifiers to say how to play with that key, and then an expr on
how to generate the key given element
) people used to thinking in terms of compare subs (from C, P5, and
points of the programming universe) can still think that way.
3) most importantly to me, so that There's More Than One Way to Do It.
-- Rod Adams
looks very good.
Yeah Damian!
-- Rod Adams
PS -- Only pure and utter insanity would lead someone to not make string
the default sort comparator, and I don't think I've heard anyone here
mention they are in favor of doing anything else.
Damian Conway wrote:
Richard Nuttall suggested:
An alternative is to have fill rightmost gaps and fill leftmost
gaps on
alternate lines. This produces more balanced looking columns, so
they don't all look heavier on the left.
That's a *very* interesting idea. What do people think?
The
. But that's a p6i problem, not a p6l one.
Another way to interpret this post is When is SMD preferred over MMD?
And is that enough to make it the default?
If I'm missing something basic feel free to correct me.
-- Rod Adams
Larry Wall wrote:
In general it's probably a lousy idea to rely on #!/usr/bin/perl6 to
select language since you want the version number to select the
version of Parrot you're running, not the version of Perl.
One thing that occurred to me over the weekend is that we could fix all
the one-liners
Luke Palmer wrote:
Admittedly, if you use == for everything, you can force string or
numeric comparison this way:
if +$a == +$b {...} # numeric
if ~$a == ~$b {...} # string
Hmm.
In my head, I would expect == to have implicit numification on the
operands (unless user-overloaded to
Luke Palmer wrote:
Oh, sorry, wasn't clear. That's *if* eq was eliminated and == became a
polymorphic operator.
You're correct in terms of the current (and hopefully continuing) state
of things.
Went back and re-read your first post, and that is indeed what you were
saying, I just read it too
Smylers wrote:
Gabriel Ebner writes:
Joe Gottman wrote:
The zip operator is now the Yen sign (¥).
How are those without a US keyboard supposed to type this?
On Windows you can probably press Alt Gr then type in some number.
Close. AltGr-Minus. If you're using the
. If, however, you remap your keyboard (easily
doable in X and Win32, I'd assume Macs can as well), then the common
Unicode characters are an AltGr away. Thus, « one shifted keystroke
(AltGr-[), is two shifted keystrokes (Shift-, Shift-,).
-- Rod Adams
Come the glorious age of Perl6, will hash slices be enhanced to allow
things like the following?
[EMAIL PROTECTED]'expected'} = [EMAIL PROTECTED];
Specifically, having the slice be something other than the last element.
This likely dictates having {} be able access a list of of hashrefs, not
Brent 'Dax' Royal-Gordon wrote:
David Storrs wrote:
Well, at least that's a nice simple explanation. Why couldn't anyone
have explained it to me that way before? Unfortunately, it means that
continuations are a lot less useful than I thought they were. :
Actually, I think you're
Austin Hastings wrote:
--- Rod Adams [EMAIL PROTECTED] wrote:
A guess from my current understanding:
You're wanting to play with a database. You take a continuation. You
see
if have a database handle open and good to go, if so you do your
thing.
(can you then dismiss the continuation? do
relate to what I saw being discussed.
Oh, and TextFile should be spelled IO::File::Text, IMHO.
-- Rod Adams
Dave Whipp wrote:
Rod Adams [EMAIL PROTECTED] wrote in message
news:[EMAIL PROTECTED]
Uhm, my impression was that most of the huffmanization discussion was
centered around declaring a file handle to be read only, write only,
read-write, exclusive, etc. Masking the file handle with what
with these specifications, not Open a file, and then
apply these specifications to it.
I do admit there is merit to your abstraction system, but IMO, it
belongs in a library.
-- Rod Adams
Austin Hastings wrote:
--- Rod Adams [EMAIL PROTECTED] wrote:
I think part of the mental jam (at least with me), is that the
read/write, exclusive, etc, are very critical to the act of opening
the file, not only an after the fact restriction on what I can do
later.
But why? I'd argue
with),
+$verbose,
+$foo
} returns Array | undef {
# real code here
}
-- Rod Adams
to construct my own map like functions,
and have creating them with pipeline performance in mind to be easy.
Just a thought, since with the creation of == and ==, pipelining is
bound to become an even more common construct.
-- Rod Adams
Randy Sims's test case:
#!/usr/bin/perl
use strict;
use
Aaron Sherman wrote:
On Mon, 2004-08-30 at 16:34, Rod Adams wrote:
@x = @y == map lc == grep length == 4;
I would think you actually want to be able to define grep, map, et al.
in terms of the mechanism for unraveling, and just let the optimizer
collapse the entire pipeline down
Larry Wall wrote:
On Fri, Sep 03, 2004 at 05:45:12PM -0600, John Williams wrote:
: What happens when the Pascal programmer declares
:
: my int @ints is shape(-10..10);
:
: Does it blow up?
No.
: If not, does @ints[-1] mean the element with index -1 or the last element?
The element with
Larry Wall wrote:
I'm still thinking A is the first one and Z is the last one. Someone
talk me out of it quick.
I had thought about A and Z before my previous post. I dismissed it for
two reasons:
1) Using Alphas as an index for something that should be numeric can be
very confusing.
Luke Palmer wrote:
Jonadab the Unsightly One writes:
Rod Adams [EMAIL PROTECTED] writes:
One solution I see to this would be to have a lazy return of some
kind, where you can send out what results you have so far, but not
commit that your execution is over and still allow further results
in the Impatience department.
(I need more sleep)
-- Rod Adams
in the core documentation as a learning tool, would do the job
nicely. And it doesn't need to be discussed on p6i, p6l, or p6c, at
least not for a very long time.
Or we could just burn a RE parser into everyone's brain, as you
mentioned. That'd also work.
-- Rod Adams
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 P6
::list ratio, as that will cover
some {insert randomly high %age} of all cases. For the other cases,
you're likely better off building a class with two emitter methods, and
possibly even use Ctie to make it look like two lazy lists.
-- Rod Adams
The thing about lists is that they are linear
in your code?
btw, should it be », «, or »«?
-- Rod Adams
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
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
== Cpop in standard implementations.
So Cenq and Cshift? 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 $c $d ) {...}
In line2, my mind has
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;
@x ==$foo; # @x = =$foo; @x
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;
: [EMAIL PROTECTED]; # $x ** [EMAIL PROTECTED]; $x **= @y;
In each of those cases the longest-token
a P5 $punct.
-- 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
;
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
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
,
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.)
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 = any( (1
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;
dog
cat
Would that happen
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
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 $b) ^ ($c $d
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.
Csay @what is just a shorthand for Cprint @what, \n.
So saying a junction is the same as printing it, which is a run
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
to determine if we should be able
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 object-oriented language
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
-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
)) == 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
.
As for the undef's, I didn't know what else to call the empty junctive.
-- Rod Adams
the nestedness of it,
or removing terms outright. In the process, I'm making sure that I
understand what they mean.
-- Rod Adams
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
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 Cwhen 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 Cwhen to accept a list of things to compare against,
followed
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. And I now must
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
overloads the various comparison
effects possible for the evaluation of that operator. By
the time the operator gets called, it should have all the parameters it needs, and there are no
more side effects to be had.
As for C .. , 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..sqrt(3|5)) {...} mean
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|4|5|6) {...}
Would pass
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 it doesn't say it can
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 Cuse junctions in scope where $x was
assigned
generate. To
keep the power of junctions viable, explicit threading should be
trivially easy, but it should be explicit, none the less.
-- Rod Adams
of the weird things you
have to live with if you're playing with junctions?
-- Rod Adams
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. Cuse junctions and Cno
junctions), we can just
, 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
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 as hold and contain
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 a list
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
. (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
attribute, so we can say:
$x, $y, $z are mine! mine! mine!;
(Must be spoken like a three year old when read.)
-- Rod Adams
of this code, I apologize. But it
certainly fits my understanding of junctions, which has grown by leaps
and bounds over the last few weeks.
HTH,
-- Rod Adams
Luke Palmer wrote:
The object model that I'm working on actually identifies 2 and 2 as
the same object, indistinguishable in every respect.
Okay, that's fine, since C 2 eq 2 and C 2 == 2 . But what about
2.0 and 2.0?
In Perl5, C 2.0 == 2.0 , but C 2.0 ne 2.0 .
-- Rod Adams
Larry Wall wrote:
On Tue, Mar 01, 2005 at 11:06:17PM -0600, Rod Adams wrote:
: Since the line between rules and subs is already blurring significantly,
: I want to blur it a little more. I want to write rules which can take
: parameters.
No problem. That's how the arguments to rules like
':
sub equal ($x, $x) { 1 }
sub equal ($x, $y) { }
That's one of the MTOWs at least. The evaluation order of the patterns
still needs to be thought out.
I thought Larry already declared that we are not making Perl act like ML
(yet).
-- Rod Adams
Autrijus Tang wrote:
On Tue, Mar 08, 2005 at 04:55:28PM -0600, Rod Adams wrote:
I thought Larry already declared that we are not making Perl act like ML
(yet).
And that was re: type inferencing, not re: pattern matching. :)
Thanks,
/Autrijus/
Sorry about that. Comcast has decided I
.
There are likely several rough edges in here, and I've by no means
convinced myself that this is the Right Thing, but I thought I'd throw
the idea out there to what others thought of it.
-- Rod Adams.
well with the rest of Perl6.
It's a lot more work to build than the equiv Prolog statement, but I
can't justify the level of effort it would take to define and implement
the auto-generation capabilities.
-- Rod Adams
Luke Palmer wrote:
Rod Adams writes:
Or you could avoid the global modifier and write your tests in ( )
blocks instead... after all, that's what it's there for.
I *knew* I had seen a syntax for that before... I just didn't see it
when I scanned S05 for it.
I still want the :z modifier
Thomas Sandlaß wrote:
Rod Adams wrote:
It seems to me that there are several advantages to making a group of
multi with the same short name a single object, of type
MultiSub|MultiMethod, which internally holds references to the all
the various routines that share that short name.
It doesn't
Larry Wall wrote:
On Wed, Mar 09, 2005 at 06:19:25AM -0600, Rod Adams wrote:
: I was thinking more along the lines of :
:
:use MMD::Pattern;
:
:our func is MMD::Pattern;
:
:multi func (...) {...}
:multi func (... ...) {...}
:multi func (... ... ...) {...}
:
:multi func2
seem
to be trying to get into Perl in some fashion or another. I can easily
wait until 6.2 for this to happen (for now at least).
-- Rod Adams
1 - 100 of 219 matches
Mail list logo
