(Add disable => 'superposition' to 'use hints' call to
disable this message.)
...
Just tell newbies to always 'use hints;', and they'll be fine.
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Config
Larry Wall:
# and then I looked crosseyed at the // vs \\ proposals, and I
# realized we have a superposition of / and \ that is spelled "X". :-)
use Perl::Caseless;
print "foo" x 6; #?!?
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"P
...
last CHECK;
}
last LOOP;
}
}
# The only difference is that in Perl 6, there is no cat. :-)
Ah, I see that my diabolical scheme for World Domination is proceeding
as planned...
--Brent Dax <[EMAIL PROTECTED]>
@
Larry Wall:
# Besides, Windows programmers would continually be writing
#
# $a / $b
*rolls eyes*
(Yes, I know that's a joke. (It is, isn't it? :^) ))
--Brent Dax <[EMAIL PROTECTED]>, Windows Perl and Parrot hacker
@roles=map {"Parrot $_"} qw(embedding regexen Con
Larry Wall:
# We're obviously missing the "force to string context, negate"
# operator. :-)
Which would create a superposition of all strings besides the given one,
right? (Oh crap, I think I gave Damian an idea... :^) )
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {&quo
extra brackets lying around without going to
# Unicode...
Can the new nefarious use be concat? Pretty please?
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
Wire telegraph is a kind of a very, very long cat. You pull his tail in
Ne
Nicholas Clark:
# I read this and I think
#
# sub ... () of Borg { }
sub ven () of Nine { ... }
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
Wire telegraph is a kind of a very, very long cat. You pull his tail in
New York
h 'bitand' and 'bitor' (or even 'mask' and 'combine', or
something to that effect)?
5) if( $vec bitor $mask bitand $mask )
6) if( $vec combine $mask mask $mask )
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexe
s for pointing that out, Larry.)
Parens don't construct lists EVER! They only group elements
syntactically. One common use of parens is to surround a
comma-separated list, but the *commas* are creating the list, *not* the
parens!
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Par
w_bar;
}
else {
$.bar;
}
}
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
Wire telegraph is a kind of a very, very long cat. You pull his tail in
New York and his h
x
The "correct" behavior (IMHO) is the third, though I could see the
second. But the first is unacceptable.
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
Wire telegraph is a kind of a very, very long cat. You pull his
ly. In some cases you want $_
dynamically, in others lexically. Perhaps C<$_ is topic('lexical')> and
C<$_ is topic('dynamic')>?)
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
Wire telegraph is a kind of a
er my question. :^) What's
the *language-level* behavior?
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
Wire telegraph is a kind of a very, very long cat. You pull his tail in
New York and his head is meowing in Los Angeles. And radio ope
^+ @bar; # ???
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
Wire telegraph is a kind of a very, very long cat. You pull his tail in
New York and his head is meowing in Los Angeles. And radio operates
exactly the same way. The only di
Aaron Sherman:
# On Thu, 2002-09-12 at 21:10, Brent Dax wrote:
# > Aaron Sherman:
# > # I'm thinking XS thoughts
#
# > # Something like:
# > #
# > # module somesuch;
# > # use External (language=>"C");
# > # sub chdir(string $path //= $ENV{
);
use Parrot::XS::Inline;
inline C => qq{
#include
};
sub chdir(string $path //= $ENV{HOME} is external('C', 'int',
'char*') returns(int);
sub curdir() is external('C', 'cha
would cause it to collapse
to one of the possibilities. :^)
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
"In other words, it's the 'Blow up this Entire Planet and Possibly One
or Two Others We Noticed on our Way Out Here' operator."
--Damian Conway
te($targname);
for @names -> $name {
$scope.num{$name} = $num;
}
}
}
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configur
; # XXX - How does code get
$_?
It should be C. A closure that receives one argument and
doesn't have a signature gets that argument put into $_.
Overall, things look roughly correct. Well done.
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexe
Damian Conway:
# Neither. You need:
#
# $roundor7 = rx /<+[17]>/
#
# That is: the union of the two character classes.
How can you be sure that is implemented as a character
class, as opposed to (say) an alternation?
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {&qu
foo {}
open foo, ">foo";
print foo $x; #filehandle or function call?
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
"In other words, it's the 'Blow up this Entire Planet and Possibly
. :^) )
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
"Java golf. That'd be a laugh. 'Look, I done it in 15!' 'Characters?'
'No, classes!'"
--Ferret, in the Monastery
t may be up
to a day before your favorite mirror has a copy.
Share and enjoy.
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
He who fights and runs away wasted valuable running time with the
fighting.
-Original Message-
The uplo
avoid stepping on toes. :^)
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
He who fights and runs away wasted valuable running time with the
fighting.
{ \( ( <-[()]> | ) \) }
The key to balanced delimiters is recursion. A5 gives us convenient
recursion; therefore, it gives us balanced delimiters.
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
He who fights and runs away wasted valuable
the flexibility you wanted? ;^)
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
He who fights and runs away wasted valuable running time with the
fighting.
gfiles, since many of
them are too stupid to use -w and won't expect any warnings.
I think people will find the idea of saying @a ^+ @b really weird as it
is, without it sneaking up on them when they're not looking.
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
He who fights and runs away wasted valuable running time with the
fighting.
es in text. :^) ) Reading
this, I noticed a potential problem in :w.
To put it simply, what do these expand to?
m:w/foo [~|bar]/
m:w/[~|bar] foo/
m:w/[~|bar] [^|baz]/
m:w/@foo @bar/
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding
David Whipp:
# Brent Dax wrote:
# > $href = hash { %hash }; #B
#
# Why the curlies? if C is a function (ctor), then surely
# these should be parentheses. In this context, parentheses are
# optional, so this could be written
#
#$href = hash %hash;
C is not a function. It&
s.
Autodereferencing happens whenever we have a scalar but we need an array
or hash; autoreferencing happens whenever we have an array or hash but
need a scalar (usually because of scalar assignment, but not
necessarily).
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
He who fights and runs away wasted valuable running time with the
fighting.
ectorization happens, and with the ability to
# define your
# > own array behavior, you can pretty much do this however you
# want anyway.
#
# Yes but it would be nuts to have PDL arrays do things one way
# and inbuilt
# compact arrays do things another way.
No, it wouldn't. PDL is
xt() keyword would be like the opposite of want(). Of course,
something like:
context $x: foo();
Might not work.
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
He who fights and runs away wasted valuable running time with the
fighting.
and converting those that only
contain pairs.)
# (I hope the answer isn't "white space" . . )
#
#
# [Hi, I'm new around here, so I'll give you the three-line
# introduction. I teach Perl at Monash Uni, my office is in the
# same corridor as Damian's, and I like cats, chocolate, and
# curry. (Not all at once.) ]
Well, any friend of Damian's... :^)
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
He who fights and runs away wasted valuable running time with the
fighting.
tation language) and a willingness to dig
# through the Apocalypses and Exegeses. (Well, that and not minding the
# first version likely getting tossed out when we do the final
# implementation... :)
If we can use a real parser (Parse::Yapp, Parse::RecDescent), I'd love
to help. If not...we
er a valid delimiter, and if you want a balanced
one '[' is usually ideal.
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
Early in the series, Patrick Stewart came up to us and asked how warp
drive worked. We explained
next>/ && $best &&
# $0.length < $best.length {
# }
# fail unless $best;
# let $0 := $best;
# .pos = $best.pos;
# }}
#
# then:
#
# "bacamus" =~ / /;
Will that handle captures correctly? Maybe you should temporiz
mplementing their interpreters in Perl... ;^)
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
Early in the series, Patrick Stewart came up to us and asked how warp
drive worked. We explained some of the hypothetical principles . . .
&qu
Larry Wall:
# On Fri, 7 Jun 2002, Damian Conway wrote:
#
# > Brent Dax wrote:
# >
# > > grammar Perl6::Regex {
# > > rule metachar { <[<{(\[\])}>:*+?\\|]>}
# > >
# > > rule ws { [<[\h\v]>|\#\N*]*
\{ \}
| \< !? [ \w+ | \d+ , \d+ ] \>
)
}
}
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
Early in the series, Patrick Stewart came up to us and asked how warp
drive worked. We explained some of the hypothetical principles
nterpreted the same way, but typed a bit differently. It won't
match your regex.
The moral of the story is that you should not try to parse the *MLs with
regexen--use modules instead.
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure
ones, obviously).
#
# There. Nearly 3% of the CPAN ported in two fell swoops! ;-)
Why bother? You've already put P::RD and T::B effectively in the core!
;^)
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
blink: Text blinks (alternat
all round.
Just because we're trying to make radical changes doesn't mean we can't
make a small sacrifice to the backwards-compatibility gods. After all,
it would be kinda nice if there were users besides p6* list members, and
I doubt it'll work without at least the small sacrifi
kes sense to me.
I'm sure it's still there. Otherwise there's no way to take a reference
to a scalar.
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
blink: Text blinks (alternates between visible and invisible).
Conformin
Luke Palmer:
# sub myint($x) { my $i = int $x; $i == $x ? $x : $i }
sub myint($x) { int $x // $x } #assuming it returned undef
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
blink: Text blinks (alternates between visible and invisi
g all of
# these as holes would be too much IMO.
That's fixed in 5.8--it uses B::Deparse to make a rough version of the
sub. Just hope it isn't a closure.
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
blink: Text blinks
Allison Randal:
# On Wed, May 01, 2002 at 01:04:10PM -0700, Brent Dax wrote:
# >
# > *bites back sarcastic comment about the pace of Perl 6's
# development*
#
# *fails to squelch reply about the survival rate of prematurely birthed
# babies*
#
# Some things just take time.
I kn
Graham Barr:
# On Wed, May 01, 2002 at 12:17:52PM -0700, David Wheeler wrote:
# > On 5/1/02 12:11 PM, "Brent Dax" <[EMAIL PROTECTED]> claimed:
# >
# > > It's far too late to make it into 5.8, but it looks like
# it'll be in
# > > 5.10 when that come
Mark J. Reed:
# On Wed, May 01, 2002 at 12:11:58PM -0700, Brent Dax wrote:
# > It's far too late to make it into 5.8, but it looks like
# it'll be in
# > 5.10 when that comes out (in a year or two).
# .. . . by which time 6.0 will have already been released, right?
#
# Rig
David Wheeler:
# On 4/17/02 10:02 PM, "Brent Dax" <[EMAIL PROTECTED]> claimed:
#
# > I'm working on a preliminary version right now. So far it's been
# > surprisingly easy--touches toke.c, perly.y, opcode.pl, pp.c, and
# > pp_hot.c. (Of course, it'
Sorry to reply to the same message twice, but I just noticed something.
Larry Wall:
# {n,m}
Isn't that the only use of angle brackets as a quantifier? That's going
to make parsing more difficult...
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_&q
Piers Cawley:
# "Brent Dax" <[EMAIL PROTECTED]> writes:
# > Larry Wall:
# > That's...odd. Is $$ (the variable) going away?
# >
# > # /./s // or /<.>/ ???
# >
# > I think that . is too common a metacharacter to be
# relegated to
ks like and
that this will work on it.
For this simple reason, I highly suggest somehow hijacking curlies
instead, and perhaps making embedded code use two curlies. After all,
regexes are intimidating enough already. :^)
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
#define private public
--Spotted in a C++ program just before a #include
mention that.
[3] This seems a bit useless to me too. It's probably more useful to
have a /r modifier on the entire regex.
[4] I changed the ordering for this one to avoid an ambiguity.
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
#define private public
--Spotted in a C++ program just before a #include
y, opcode.pl, pp.c, and
pp_hot.c. (Of course, it's also off an old bleadperl, but I doubt those
files change that actively.)
BTW, so far toke.c hasn't been as bad as I've heard it is. :^)
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
#define private public
--Spotted in a C++ program just before a #include
#x27;s expecting a binary
operator or Something Else. That's how it handles things like
vs. numeric less-than (<).
I think, that is. I've always heeded Larry's warning from Camel III
that the tokenizer "has been known to induce eating disorders in lab
rats" (p467). :^
pport the Perl 5 blockless style.
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
#define private public
--Spotted in a C++ program just before a #include
Uri Guttman:
# >>>>> "BD" == Brent Dax <[EMAIL PROTECTED]> writes:
#
# BD> I think qn counts as weird syntax. I ask again, what's
# wrong with one
# BD> of:
#
# BD> sprintf("%hash\%s", $string);
#
# BD> sprintf(%h
ber this or haven't read about it somewhere, open() was once a
hybrid unary and list operator, so "open FOO, 'bar' || die;" worked.) A
minor adjustment in either the language or the user's usage was all that
was necessary to avoid problems with the change
--Brent
seems to
# have some backing and it is clean and unobtrusive.
I think qn counts as weird syntax. I ask again, what's wrong with one
of:
sprintf("%hash\%s", $string);
sprintf(%hash.'%s', $string);
sprintf('%s%s', _%hash, $string);
?
--Brent
%d hash is %s', $bar, %foo;
? After all, interpolating into an sprintf is a bit dangerous anyway
(what if %foo=('%d' => '')?), and you avoid special cases.
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
#de
else {#which leaves this else dangling!
baz
}
# And can we assume that "on a line by itself" ignores non-$/
# whitespace?
And comments, I imagine.
--Brent Dax
[EMAIL PROTECTED]
Parrot Configure pumpking, regex hacker, embedding coder, and boy genius
#define priv
your reply and intersperse your text with the text of the
message as appropriate. I and most other people on the Perl 6 lists use
this style--it helps to provide context and remind people what the
discussion is about. Even if your mailer arranges the text so that your
style is easier (as mine does),
Sure we will. They're just not our first target. We build our own
interpreter/VM, then when that's working we start in on the JVM and/or
..NET back ends.
--Brent Dax
[EMAIL PROTECTED]
Parrot Configure pumpking and regex hacker
Check out the Parrot FAQ: http://www.panix.com/~ziggy/parrot
ach node's siblings.
Implementation-wise, things get fairly easy once the vtable->match stuff
I mentioned above is in place. Obviously we would optimize for string
matching. Also, we WILL lose some performance, even over the current
slowdown compared to Perl 5. Nevertheless, it can be
note that that still leaves grep as-is, with the old format.
Perhaps that's a clue that we should leave this alone, though perhaps
with the args to map and grep rearranged.
--Brent Dax
[EMAIL PROTECTED]
Parrot Configure pumpking and regex hacker
Check out the Parrot FAQ: http://www.panix.com/~z
d{x}",%d{x})? Is
# that a bug or does it produce "n{x}" where n is the value of
# %d{x} as an
# integer?
It produces something pretty weird. Just single-quote the format string
instead of double-quoting it.
--Brent Dax
[EMAIL PROTECTED]
Parrot Configure pumpking and regex hacker
Aaron Sherman:
# On Mon, 2002-01-28 at 11:17, Brent Dax wrote:
#
# > I'd like you to perform an exercise for me if you have a Camel III.
#
# I have a Camel 1 (pink) and 2, but not 3. However, I follow
# you. You are
# (as everyone else has fallen into the trap of) thinking of only what
#
have a Camel III.
The first thing is to open it to Chapter 4, which starts on page 111.
Now, read through Apocalypse 4, highlighting everything that's changed.
Not things that have been added--just things that have changed.
I think you'll find that Perl 6 isn't as dissimilar
. operator?
Still, though, a wonderful piece of code.
--Brent Dax
[EMAIL PROTECTED]
Parrot Configure pumpking and regex hacker
Check out the Parrot FAQ: http://www.panix.com/~ziggy/parrot.html (no,
it's not mine)
. hawt sysadmin chx0rs
This is sad. I know of *a* hawt sysamin chx0r.
I k
difference there.
Nope. 'use Foo;' is translated to 'BEGIN {require Foo; import Foo;}' by
Perl; Exporter just provides a default implementation of import().
--Brent Dax
[EMAIL PROTECTED]
Parrot Configure pumpking and regex hacker
. hawt sysadmin chx0rs
This is sad. I know of
oderef;
#
# and then wondering why it says "Undefined LAST block" or some such.
Maybe all of the [A-Z]+'s get defined each time the block is entered
(or, if the block is being iterated on, the first time the block is
entered during this set of iterations).
--Brent Dax
[EMAIL PROTE
of the current block
UNDOExecutes on "un-normal" exit of the current block
--Brent Dax
[EMAIL PROTECTED]
Parrot Configure pumpking and regex hacker
. hawt sysadmin chx0rs
This is sad. I know of *a* hawt sysamin chx0r.
I know more than a few.
obra: There are tw
We have an empty 'less' pragma in Perl 5, right?
use less '6';
use less '6' => 'path/to/perl/6/version';
--Brent Dax
[EMAIL PROTECTED]
Configure pumpking for Perl 6
"Nothing important happened today."
--George III of England's diary entry for 4-Jul-1776
Michael G Schwern:
# I've rearranged the proposed features a bit to put the long objections
# at the bottom.
#
# Brent Dax wrote:
# > I've been thinking about improvements that could be made to
# Exporter for
# > Perl 6.
# > 3. Warnings about conflicts:
# >
Bryan C. Warnock:
# On Saturday 22 December 2001 02:29 am, Brent Dax wrote:
# > I've been thinking about improvements that could be made to
# Exporter for
# > Perl 6.
# >
# > 1. Choosing where to export to:
# > use Data::Dumper 'Dumper' => 'd
Richard J Cox:
# [EMAIL PROTECTED] (Brent Dax) wrote:
# > krish:
# > # I am a beginner in Perl and have a very trivial query. I have
# > # some .expect
# [...]
# >
# > This is the wrong group for this sort of question.
# perl6-internals is
#
# s/internals/language/
Doh! got the
t; ['@argv %argv']}
);
In other files:
use MyModule; #imports everything in export
use MyModule 'quux';#imports only &quux
use MyModule ':argc'#imports @argv and %argv
use MyModule(); #imports nothing
concatenation) operators (in
perlop).
-The opendir(), readdir(), closedir(), and rename() built-in functions
(in perlfunc).
HTH.
--Brent Dax
[EMAIL PROTECTED]
Configure pumpking for Perl 6
"Nothing important happened today."
--George III of England's diary entry for 4-Jul-1776
se should be obvious. In that case, 'scalar'
context is really 'one' context. However, we can still call it scalar
context if it makes you feel better. :^) (Yes, those are just my
opinions. They do not necessarily reflect Larry's, Damian's or the guy
in the padded ce
#x27; general way to make both a scalar variable
# binding and its
# value constant?
Could you do C<%MY::{'$pre'} is constant> to lock the symbol table
entry?
--Brent Dax
[EMAIL PROTECTED]
Configure pumpking for Perl 6
When I take action, Im not going to fire a $2 million missile at a $10
empty tent and hit a camel in the butt.
--Dubya
Damian Conway:
# BTW, colon isn't an operator (it's a separator), so it can't be hyped.
What do you mean? We can hype the colon all we want! :^)
--Brent Dax
[EMAIL PROTECTED]
Configure pumpking for Perl 6
When I take action, Im not going to fire a $2 million missile at a $10
7;apple'); # green
$obj.fruit{apple}
# Regardless of whether something like the above two examples
# can/will be
# auto-created, what would those methods look like anyway?
# Would they simply
# be:
#
# method colors is lvalue { return @.colors }
# method fruit is lvalue { return %.fruit
to know if I'm at least right about the
placement of 'type'.
--Brent Dax
[EMAIL PROTECTED]
Configure pumpking for Perl 6
When I take action, Im not going to fire a $2 million missile at a $10
empty tent and hit a camel in the butt.
--Dubya
*BabyPerl is a program I'm wor
uld seem unfair to ban the use of
colon on method calls, or to make you declare a self; perhaps:
method bar($a, $b: $c, $d) {
...
}
That still leaves the case of C<< $obj->bar($a: $b, $c) >>. Perhaps:
method bar(: $a: $b, $c)
would work f
Those alternate universe syntaxes coming from quantum fluctuations in
# the uncollapsed syntax superposition. I'll soon be firing a polaron
# burst through the main deflector in a desparate attempt to stabilize
# this anomoly before it destroys Perl 6.
All these Star Trek references a
I'm back. I notified Simon on the tenth that I was going to be away
until today. I'm trying to catch up on the nine-hundred-odd messages
the p6? and p5p have thrown at me, so I may be realistically out of
commission for a couple days more.
--Brent Dax
[EMAIL PROTECTED]
Configure pu
complete
Followed by the catch-all:
Cannot continue after parsing errors
I've pasted a program below that shows much of what it can handle.
babyperl.pl is attached to this e-mail. It's over 600 lines, and very
messy. I will likely rewrite the whole thing Real Soon Now to make it
nsistency, I'd prefer to use is: 3+(2 is i). Well, either way,
this is a good thing for properties to handle. GO PROPERTIES! ;^)
--Brent Dax
[EMAIL PROTECTED]
Configure pumpking for Perl 6
They *will* pay for what they've done.
think of it as a "skewed or", which is, er,
# both what it both is, and what it looks like.
If we have 'and', 'or' and 'xor', can we have 'dor' (defined or) to be a
low-precedence version of this?
--Brent Dax
[EMAIL PROTECTED]
Configure pumpking for Perl 6
They *will* pay for what they've done.
y for waking up perl6-language. I
had seen almost no traffic on it in weeks, and was starting to get a bit
worried that thoughts on the languages were coughing, sputtering and
dying. :^)
--Brent Dax
[EMAIL PROTECTED]
Configure pumpking for Perl 6
They *will* pay for what they've done.
e is the only eccentricy I have left from my early work in (ugh) VB
print $fh: .quux; #same as $me.quux
print $fh: .gerflonkurator; #same as $me.gerflonkurator
}
Cool.
--Brent Dax
[EMAIL PROTECTED]
Configure pumpking for Perl 6
They *will* pay for what they've done.
ing by someone who
knows more than me. :^)
--Brent Dax
[EMAIL PROTECTED]
Configure pumpking for Perl 6
They *will* pay for what they've done.
parser that smart?
#
# Just curious...
Hmmph. My guess is that you'd have to do something like <($counter >
1000 ?? $file1 :: $file2)> and the fact that there are open parens at
the first greater-than would be enough for the parser to figure it out.
--Brent Dax
[EMAIL PROTECTED]
Configure pumpking for Perl 6
They *will* pay for what they've done.
_($$)) ($x, $y)
# { $x _ $y }
#
# etc.
Of course. OTOH, people will scratch their heads when they come upon
$foo § $bar or whatever.
On a separate note, how will '$foo??Bar::baz::frob' parse?
Since I've been complaining a lot, I'll now say a bunch of the things I
do like:
^
//
Now, will use ~.
With the many different opinions on this, maybe we should
just have three or four different concat operators...
--Brent Dax
[EMAIL PROTECTED]
Configure pumpking for Perl 6
They *will* pay for what they've done.
-Interpolation
-Operator precedence
-Comparison operators
-And and Or
-Anything not already implemented in Parrot
print() currently only takes one parameter, but you can use ~ to
concatenate things together. It spits out a crapload of debugging
information--symbol ta
Uri Guttman:
# $fh.irs( 'Peterbilt' ) ;
We're going to have an IRS property on filehandles? God, I can hear the
jokes already...
--Brent Dax
[EMAIL PROTECTED]
Configure pumpking for Perl 6
They *will* pay for what they've done.
e is in a try block;
otherwise we get the same die-at-compile-time behavior.
In other words, I want exceptions thrown at compile-time to be catchable
at run-time by surrounding try blocks. Are there any barriers to this
working? If so, what are they?
--Brent Dax
[EMAIL PROTECTED]
They *will* pay for what they've done.
rograms in the OISC machine language are included.
We now have available have a revised and expanded version of oisc called
OIC. In the future, this may replace OISC."
from http://www.tuxedo.org/~esr/retro/
:^)
--Brent Dax
[EMAIL PROTECTED]
"...and if the answers are inadequate, the pumpqueen will be overthrown
in a bloody coup by programmers flinging dead Java programs over the
walls with a trebuchet."
$AUTOLOAD is in.)
The second step takes care of resolving the address of the function; it
handles picking which (if any) of the prototypes available for the
method is appropriate for those parameters. Its implementation is left
as an exercise to the reader. :^)
--Brent Dax (who finds it very amu
201 - 300 of 324 matches
Mail list logo
