On 9/5/05, Juerd [EMAIL PROTECTED] wrote:
Thomas Sandlass skribis 2005-09-05 14:38 (+0200):
b) if this is true, ?? evaluates its rhs such that it
can't be undef
But
$foo ?? undef // 1
then is a problem.
Yeah. Hmm, but I kinda like the look of ?? //, and I don't like
On 9/6/05, Damian Conway [EMAIL PROTECTED] wrote:
Luke wrote:
Yeah. Hmm, but I kinda like the look of ?? //, and I don't like the
overloading of :: in that way anymore. So it's possible just to add
a ternary ?? // in addition to, and unrelated to (from the parser's
perspective),
On 9/6/05, Thomas Sandlass [EMAIL PROTECTED] wrote:
Right. To make :: indicate type or meta was my primary concern.
Okay, now why don't you tell us about this new binary :: you're proposing.
Luke
On 9/3/05, Damian Conway [EMAIL PROTECTED] wrote:
H. The arity of a given multi might be 3 or 4 or 5.
If *only* there were a way to return a single value that was simultaneously
any of 3 or 4 or 5.
Oh, wait a minute...
Well, we'd better document that pretty damn well then, and provide
On 9/7/05, Damian Conway [EMAIL PROTECTED] wrote:
Luke wrote:
In that last case though, this is not equivalent to the above:
given code.arity {
when 2 { code(1,2) }
when 1 { code(1) }
}
That may be a little... surprising. Still, it's fixed to
On 9/7/05, Brent 'Dax' Royal-Gordon [EMAIL PROTECTED] wrote:
Here's a Real Live Perl 6 module I wrote recently. I've omitted a few
magic portions of the code for clarity.
Thanks for real live perl 6 code. It's always nice to have real examples.
However, I'm arguing for logical stability
On 9/8/05, Damian Conway [EMAIL PROTECTED] wrote:
Luke wrote:
Okay, fair enough. The reason that I thought it was surprising is
because 1 and 2 are usually orthogonal patterns.
It depends what they're doing. Matched against a regex like /[12]/ they're
not orthogonal either.
Well,
On 9/8/05, Benjamin Smith [EMAIL PROTECTED] wrote:
Pugs currently implements infix:!! as an ugly version of the
infix:nor operator.
Are these in the spec?
No they are not. Destroy!
Luke
I think we should generalize the hyper stuff a little bit more. I
want hyper operators serve as fmap, or functor map, rather than
just list. This is a popular concept, and a pretty obvious
generalization.
A functor is any object $x on which you can do fmap such that it
satisfies these laws:
On 9/11/05, Stevan Little [EMAIL PROTECTED] wrote:
Hello all.
I have some questions about how Roles will behave in certain
instances, and when/where/what $?ROLE should be bound too.
1) Given this example, where 'bar' is a method stub (no implementation)
role Foo {
method bar { ...
On 9/12/05, Yuval Kogman [EMAIL PROTECTED] wrote:
Hi,
Hi. These are superficial thoughts, before I've had time to really
think about the Big Picture.
2. each block of code has a cryptographic digest, which is the hash
of it's body with the digests of all the functions it calls.
On 9/14/05, Juerd [EMAIL PROTECTED] wrote:
Instead, if you don't want something to coerce, be explicit:
$foo.does(Blah) or fail;, or even: $foo.isa(Blah) or fail;.)
We've been thinking of changing .isa to something longer, or a method
on .meta, because it's a notion that is often misused. Use
Okay, due to some discussion on #perl6, I'll assume that the reason my
fmap proposal was Warnocked is because a fair number of people didn't
understand it. Also, for the people who did understand, this message
includes a complete proposal for the workings of Junctions that will
fluster Damian
On 9/19/05, Stuart Cook [EMAIL PROTECTED] wrote:
On 19/09/05, Luke Palmer [EMAIL PROTECTED] wrote:
Part 1: fmap
I have a plan for the $x »+« $y form (and also foo(»$x«, »$y«, »$z«)),
but I don't want to go into that right now. It basically involves
zipping the structures up into tuples
On 9/19/05, Luke Palmer [EMAIL PROTECTED] wrote
Well, I've written up the details in a 40 line Haskell program to make
sure it worked. I think I deleted the program, though.
Nope. Here it is. And it was 22 lines. :-)
http://svn.luqui.org/svn/misc/luke/work/code/haskell/hyper.hs
Luke
On 9/22/05, Carl Mäsak [EMAIL PROTECTED] wrote:
FWIW, to me it looks fairly intuitive. undef here means don't alias
the element, just throw it away... gaal joked about using _ instead
of undef. :)
Joked? Every other language that has pattern matching signatures that
I know of (that is, ML
On 9/25/05, Yuval Kogman [EMAIL PROTECTED] wrote:
I propose a new model - each exception has a continuation that
allows it to be unfatalized.
I think we've already talked about something like this. But in the
presence of use fatal, it makes a lot more sense.
Something comes to mind:
use
On 9/25/05, Juerd [EMAIL PROTECTED] wrote:
We can do better than equivalence testing for colors. Instead, try to
match. Surely a *smart* match operator really is smart?
$color ~~ '#FF00FF'
==
$color ~~ 'magenta'
==
$color ~~ [ 255, 0, 255 ]
Hmm. That
On 9/29/05, Dave Whipp [EMAIL PROTECTED] wrote:
for grep {defined} @in - $item, ?$next {
print $item unless defined $next $item eq $next;
}
This is an interesting idea. Perhaps for (and map) shift the
minimum arity of the block from the given list and bind the maximum
arity. Of
On 9/29/05, Austin Hastings [EMAIL PROTECTED] wrote:
Luke Palmer wrote:
This is an interesting idea. Perhaps for (and map) shift the
minimum arity of the block from the given list and bind the maximum
arity. Of course, the minimum arity has to be = 1 lest an infinite
loop occur
On 9/29/05, Austin Hastings [EMAIL PROTECTED] wrote:
Matt Fowles wrote:
for (1, 2) - ?$prev, $cur, ?$next {
say $prev - $cur if $prev;
say $cur;
say $cur - $next if $next;
say next;
}
[...]
I assume so because it's the only execution path that seems to work. But
that
On 9/30/05, Damian Conway [EMAIL PROTECTED] wrote:
Rather than addition Yet Another Feature, what's wrong with just using:
for @list ¥ @list[1...] - $curr, $next {
...
}
???
Thanks. I missed that one.
However, I think your point is pretty much the same as
On 10/1/05, John Macdonald [EMAIL PROTECTED] wrote:
I forget what the final choice was for syntax for the reduce
operator (it was probably even a different name from reduce -
that's the APL name), but it would be given a list and an
operator and run as:
my $running = op.identity;
On 10/1/05, David Storrs [EMAIL PROTECTED] wrote:
All in all, I think that might just be the end of the tunnel up
ahead. Go us for getting here, and loud applause to @Larry for
guiding us so well!
Applause for p6l for hashing out the issues that we didn't think of.
I recently wrote a Perl 6
On 4/13/07, brian d foy [EMAIL PROTECTED] wrote:
Which then makes me think I'd want to do something a bit wacky to see
if the modtime is greater than 5:
doc ~~ M = any( 5 ..* );
Or even doc ~~ M = (5..*). Then again, (doc ~~ :M) ~~ 5..* does
the same thing, without having to have pattern
On 4/17/07, [EMAIL PROTECTED] [EMAIL PROTECTED] wrote:
Note that unless no longer allows an else
Hmm, that's interesting. I don't _think_ I'm opposed, but maybe I am.
The main case that I can see this limiting me is where I like to put
my error conditions at the end of my code, out of the
On 4/27/07, Larry Wall [EMAIL PROTECTED] wrote:
: Are you sure you want to guarantee left-to-right starting
: position order? If there are multiple processors available, and
: in a lazy context, it may be preferrable to not guarantee any
: order. Then, if one processor that starts at a later
On 5/1/07, Smylers [EMAIL PROTECTED] wrote:
What are the situations in which a programmer really needs to open
something but doesn't know wether that thing is a file, a directory, or
a URL? I'm still unpersuaded this is sensible default behaviour.
Lots of times. It's an agnosticism, meaning
On 5/15/07, Dave Whipp [EMAIL PROTECTED] wrote:
A slightly tangental thought: is the behavior of Cgiven with no block
defined? I.e. is
given $foo { when 1 {...} };
equivalent to
given $foo;
when 1 {...};
Doubtful.
However, I do think that it's useful to be able to treat the rest of
the
On 6/11/07, Jonathan Lang [EMAIL PROTECTED] wrote:
[EMAIL PROTECTED] wrote:
Besides ?? !! with out an else part is just .
No, it isn't. While behaves properly when the condition turns out
to be true, the result of the condition turning out to be false is
whatever the condition turned out to
On 6/25/07, Peter Scott [EMAIL PROTECTED] wrote:
I will just voice my support for putting best-of-breed modules for very
common tasks (CGI, DBI for sure) in the core.
Of course, then you get the disadvantage that most users will see new
versions of those modules as often (or seldom, as it
On 7/1/07, Amir E. Aharoni [EMAIL PROTECTED] wrote:
I got the reply that it is similar to exponentiation of variables in math:
a ** 5 == a * a * a * a * a == a
It makes sense after it is explained and i do like the rationalization
of the range as a list-like range, instead of the comma,
On 7/1/07, Amir E. Aharoni [EMAIL PROTECTED] wrote:
On 01/07/07, Luke Palmer [EMAIL PROTECTED] wrote:
/ $ntimes := (\d+) x**{$ntimes} /
The examples of := usage in S05 seem to have notation such as this:
$ntimes := (\d+)
Yes, that is correct. I've been away from the Perl 6
On 10/7/07, Mark J. Reed [EMAIL PROTECTED] wrote:
I would argue for disallowing the all-jammed-together case, lest we
run into longest-match arguments where foobar:baz is foobar: baz
but foo:barbaz is foo :barbaz. Yuck.
Uh, that doesn't make sense. Longest match arguments are leftmost, so
if
On Nov 29, 2007 6:40 AM, James Fuller [EMAIL PROTECTED] wrote:
I would argue that XML is slightly evolved 'text' and I would like to
see my fav programming language treat it as a first class citizen
internally.
I think you are falling into a classic builtin trap. The idea is that when
you
Hi Jim,
This has become quite the flame war. There seem to be two sides of
the argument, you arguing one, everybody else arguing the other.
So to bring some perspective back into this discussion, I'd like to
ask you, what would it mean to you for there to be an XML type in
core? That is,
from
On Nov 30, 2007 10:57 AM, David Green [EMAIL PROTECTED] wrote:
Maybe some kind of Advisory Board would help, where people (who
might be experts in various ways) can offer informed recommendations
on what modules make a good fit for what circumstances. Ultimately,
if this is something we want,
On Jan 4, 2008 9:18 AM, Jonathan Lang [EMAIL PROTECTED] wrote:
Joe Gottman wrote:
On the other hand, this being Perl, I do believe it should be easy to
specify the concurrent case. I think that a forall keyword (and a
givenall keyword corresponding to given) would be a good idea.
on boston.pm a thread arose about having named subs inside subs. of
course perl5 can do it but they don't do anything useful but they do
have some odd implemenation defined closure behavior.
someone brought up lisp and scheme and how they do it (differently from
each other).
well, i want
When calling a sub that has both named params and a slurpy list, the
slurpy list should always come last. If a sub has both a slurpy hash
and a slurpy list, the slurpy list should still always come last. You
simply can't credibly have anything after the slurpy list, or it'll be
slurped.
I'm not sure if it helps people understand why I'm confused by explaining
my background, but I've done exactly zero computer science, and have come
to whatever (mis)understanding of OO I have by using C++ (and then perl).
I've never used Java, but I'm aware that it has a concept of interfaces
==QUESTION
- Given the following code, what is called by $ride.current_speed()?
class Vehicle {
my $speed;
method current_speed() { return $speed; }
method set_speed($n) { $speed = $n; }
}
class Car {
submethod current_speed() {
print
1. Sub-rules and backtracking
name(expr) # call rule, passing Perl args
{ .name(expr) } # same thing.
name pat# call rule, passing regex arg
{ .name(/pat/) } # same thing.
Considering perl can't sanely know how to backtrack into a
Nick --
I've been thinking of it like this:
class int isa intlike; # and isa value or whatever
class Int isa intlike; # and isa Object or whatever
class num isa numlike; # and isa value or whatever
class Num isa numlike; # and isa Object or whatever
...
class Scalar
On Mon, Mar 17, 2003 at 11:17:21AM -0700, Luke Palmer wrote:
name(expr) # call rule, passing Perl args
{ .name(expr) } # same thing.
Considering perl can't sanely know how to backtrack into a closure,
wouldn't { .name(expr) } be equal to name(expr): instead
On Mon, Mar 17, 2003 at 07:49:36PM +0100, Matthijs van Duin wrote:
(blah blah I wrote on closures and rule-invocation)
I'm not saying rules will be implemented in such a way, but it's the first
thing that comes to mind.
Before anyone replies, I just realized I should probably just first
My main questions are:
Is there a simpler system I'm overlooking?
Which of the two systems would you prefer if speed isn't the issue?
Mechanism 1.
Which system is likely to run faster on parrot?
They're both likely to be very slow.
and maybe also:
What is the current plan?
Damian wrote:
Alternatively, this might be an ideal spot for adverbs:
return :Block @foo;
want :Method Lazy;
caller :{.label eq 'MAINLOOP};
Errr what is that odd and disturbing notation? I don't recall
ever seeing that.
[...]
return Block: @foo;
want
To save people from having to re-read the thread, here is the actual
proposal in detail again:
PROPOSAL
Replace the 'if', 'unless', 'when' statement modifiers by identically
named lowest-precedence left-associative operators that short-circuit
from right to left.
This means
Luke Palmer [EMAIL PROTECTED] writes:
However, my problem remains. What does the poor generic programmer do
when he needs generic equality!?
unfortunetly, no such thing exists.
see:
http://xrl.us/fdz
and
http://www.nhplace.com/kent/PS/EQUAL.html
although the specifics
--- Michael Lazzaro [EMAIL PROTECTED] wrote:
Note if we are truly strict about C== always meaning compare
numerically, I imagine that the line:
[EMAIL PROTECTED] == [EMAIL PROTECTED];
would in fact be identical to _this_ line:
@a.length == @b.length;# or whatever
Dave Whipp writes:
Another, very different, situation where laziness is good is to abstract
fork/join situations:
my $a is lazy_thread := expensive_fn1(...);
my $b is lazy_thread := expensive_fn2(...);
print $a + $b;
In this scenario, each expensive evaluation would be
On Monday, March 31, 2003, at 12:30 PM, Paul wrote:
I started to suggest this myself, then realized that you might not want
it to return at all if the value is false.
Yes, exactly:
sub foo(...args...) {
# We first attempt to get our return value the easy way.
# If
Since my mail server has been down for a week, I've had a lot of time
to look through Perl 6 as it stands, without being concerned with
current issues. I'll do them one-message-at-a-time (and rather
slowly, too).
The first thing I noticed was the == / eq distinction. This has been
invaluable
While my last post was about removing entities, this one will be about
adding them.
Now, I don't know what Larry has up his sleeve in this respect, but as
I see it now, Cis is too heavily overloaded. As it stands, it means
3 things:
(1) Attributing traits
(2) Inheriting base classes
Luke Palmer:
# Now, I don't know what Larry has up his sleeve in this
# respect, but as I see it now, Cis is too heavily
# overloaded. As it stands, it means 3 things:
#
# (1) Attributing traits
# (2) Inheriting base classes
# (3) Tying variables
#
# Depending on how
Smylers wrote:
Thanks to context-forcing, the string/numeric distinction is still
there, at the expense of a little extra verbosity:
+$a == +$b; # Numeric compare
~$a == ~$b; # String compare
$a == $b; # Generic compare
But what does a 'generic' compare do? While
Luke Palmer:
# The first thing I noticed was the == / eq distinction. This
# has been invaluable for scripting, but since Perl 6 is
# desiring to be more of a formal language, I'm wondering
# whether the distinction is profitable. In generic programming
# (my specialty :), it is very
use Permutations permutations compositions;
# Generate all strings of length $n
method Rule::Group::generate(Int $n) { # Type sprinkles :)
compositions($n, [EMAIL PROTECTED]) == map {
my @rets = map {
$^atom.generate($^n)
Luke Palmer [EMAIL PROTECTED] writes:
On Thu, Apr 03, 2003 at 07:29:37AM -0800, Austin Hastings wrote:
This has been alluded to before.
What would /A*B*/ produce?
Because if you were just processing the rex, I think you'd have to
finish generating all possibilities of A* before
On Thu, Apr 03, 2003 at 07:29:37AM -0800, Austin Hastings wrote:
This has been alluded to before.
What would /A*B*/ produce?
Because if you were just processing the rex, I think you'd have to
finish generating all possibilities of A* before you began iterating
over B*...
The proper
Another one of my little annonyances in the current state of P6 is how
run-time properties are accessed. Accessing properties as methods is
pretty, but I see it as potentially dangerous.
Adding a new method to a class that happens to be the same as
somebody's property would be lucky to get some
just an aside, and a bit off-topic, but has anybody considered
hijacking the regular expression engine in perl6 and turning it into
its opposite, namely making *productions* of strings/sounds/whatever
that could possibly match the regular expression? ie:
a*
producing
''
a
aa
aaa
--- Adam D. Lopresto [EMAIL PROTECTED] wrote:
I propose that since the empty pattern is no longer legal (and
about time), we use | in patterns to indicate alternation without
preference, and || to indicate try the first, then the second,
etc.
Hmm
A neat idea, but can you
I recently discovered a CPAN module called WhatIf
(http://search.cpan.org/author/SIMONW/Whatif-1.01/). This module has
the ability to provide rollback functionality for arbitrary code.
Crazy... I was just thinking about this for an experimental language
called Snapshot I'm about to implement
Maybe it's time to pick this list up again.
It seems the last thing that happened is that Mike started the
Arrays/Hashes section. That was two months ago. What's the next
thing up?
Chapter 2 of the camel seems to think that typeglobs^Wfilehandles come
next. IIRC, we haven't covered context
On Monday, May 26, 2003, at 06:51 PM, John Macdonald wrote:
This is an interesting idea. I'd add forked processes
to the list (which includes the magic opens that fork
a child process on the end of a pipeline instead of
opening a file.
I thought about that quite a bit, but fork() is a
MikeL writes:
I say this because Damian's coroutine proposal could be greatly
simplified (IMHO making it clearer and easier) if calling the sub
didn't imply starting an implicit coroutine the first time. I might
write something that exemplifies this.
I'd be quite interested in this --
I was reading about Haskell, and realized that I don't know what ::=
is supposed to mean (don't ask what that has to do with Haskell :-).
I know it's compile-time binding, but... what's compile-time binding?
Could someone who knows enlighten me, please?
Luke
But, as Luke pointed out, some of the other syntax required to make
that work is isn't particularly friendly:
coro pre_traverse(%data) {
yield %data{ value };
yield $_ for _.clone(%data{ left });
yield $_ for _.clone(%data{ right });
}
If I work
--- Michael Lazzaro [EMAIL PROTECTED] wrote:
On Wednesday, May 28, 2003, at 01:01 PM, Austin Hastings wrote:
Exampling:
sub traverse(Hash $tree) {
return unless $tree;
traverse $tree{left} if $tree{left};
yield $tree{node};
traverse $tree{right} if
Dave wrote:
Still a bit too complex for my taste: perhaps we can use Ctimeout to
generate exceptions:
my lazy::threaded $result := { slow_fn_imp @_ };
loop {
timeout(60);
return $result;
CATCH Timeout { print ...$(time)\n }
}
At last, no Ctid! (Reminder: the suggested
At 1:03 AM +0200 5/29/03, Leopold Toetsch wrote:
Luke Palmer [EMAIL PROTECTED] wrote:
I've been trying to run pbc2c.pl, and it's been dying. I traced the
problem down to Parrot::Packfile thinking that the size of the
bytecode segment is zero. However, it works fine when I use
This gives imcc a better help message, without being patronizing about
the meanings of the options (because they're clear from the long
option names). It also cleans up the option data structure in imcc
and test_main by removing the unsightly NULLs that needn't be there.
Luke
Index: test_main.c
This patch is a collection of a few small fixes vaguely related to the
lexical pads. It implements pop_pad(out PMC), banishes Intval in
favor of INTVAL, and adds some newlines to internal_exception calls.
Luke
Index: core.ops
===
Luke Palmer [EMAIL PROTECTED] wrote:
+op pop_pad(out PMC) {
+$1 = new_pmc_header(interpreter);
+stack_pop(interpreter, interpreter-ctx.pad_stack,
+ $1, STACK_ENTRY_PMC);
goto NEXT();
Do we really need a new PMC header here? The PMC already must have one
If you want really use such constructs, you can't put them in different
compilation units, because they are basically one unit.
So a BASIC IMCC program, with all of the builtin functions it needs, plus
the actual user program itself as one compilation unit? All for the sake
of a few
Adam Turoff writes:
On Sun, Jun 01, 2003 at 10:44:02PM -0600, Luke Palmer wrote:
It will still have a lot of power in text processing, and still be a
powerful quicky language, but that's no longer its primary focus --
not to say that highly structured programming is. Some applications
Here's some much-needed cmp ops.
Luke
Index: core.ops
===
RCS file: /cvs/public/parrot/core.ops,v
retrieving revision 1.274
diff -u -r1.274 core.ops
--- core.ops30 May 2003 01:06:23 - 1.274
+++ core.ops8 Jun 2003
Apologies if I've missed some earlier discussions on multimethods. The
apocolypses, exegesises and synopses don't seem to say much other than
(a) they will exist and (b) wait for apocolypse 12 for more information.
Looking over RFC 256[*] and Class::Multimethods[**] it sounds like the
Piers Cawley [EMAIL PROTECTED] wrote
Threads and Progress Monitors
Dave Whipp had some more thread questions, and wondered what would be
a
good Perl 6ish way of implementing a threaded progress monitor. Whilst
the discussion of all this was interesting, I'm not sure that
Hello.
MSVC stumble over
static struct longopt_opt_decl options[] = {
.
{'\0', 128, 0, { --gc-debug } },
{'\0', 0, 0, { } }
}
lease, replace it by
RCS file: /cvs/public/parrot/test_main.c,v
retrieving revision 1.66
diff -r1.66 test_main.c
36c36
Jonathan Sillito writes:
Here is another suggestion (I think I mentioned this in another email) we
could support a few different types of continuations. The simplest
continuation could be just a saved return address (i.e. an opcode_t*).
This would be roughly as lightweight as the current
Hmph. I thought I already sent that message correcting that error in
the cmp ops.
Anyway, here's the corrected one with a couple tests (which I should
have written in the first place).
Index: core.ops
===
RCS file:
Luke Palmer [EMAIL PROTECTED] wrote:
It appears JIT is entirely broken. It broke recently, as it was
working well for me just a couple days ago.
I'm running i686 (P3) Linux, gcc-3.2.2
I get segfaults with both imcc -Oj and parrot -j (with assemble.pl) on
mandel.pasm and a bunch
Okay, at the moment I'm working on getting an implementation of
classes and objects working. I'm also taking a look at calling speed,
as I'd really like to not suck with our call times. :)
First off, the core stuff looks good. I'd not really looked at it
until now, but now that I have,
At 4:28 PM -0600 6/12/03, Luke Palmer wrote:
Okay, at the moment I'm working on getting an implementation of
classes and objects working. I'm also taking a look at calling speed,
as I'd really like to not suck with our call times. :)
First off, the core stuff looks good. I'd
Are the register stacks saved with the continuation?
Yes, of course they are.
Er, yeah, um.. Everybody, forget everything I just said %-)
Luke
Hello,
the Linux Standard Base would like to include PERL into the standard, i.e.
a LSB conform package may use PERL without the need to pack it itself, but
PERL lacks a specification.
What would be enough is a subset of the perl language that can be tested
to be portable across perl
Hello!
Recently I was coding Perl 5 and quite often I had to change
interpolated strings or Cprint to Csprintf or printf.
I began to wonder, if qq strings couldn't allow sprintf-like
formatting directly.
I could imagine an \F escape sequence with the following syntax:
:'\F'
K Stol [EMAIL PROTECTED] wrote:
Hello,
Somehow I lost track of the thread of converting Parrot to CPS.
I missed the part in which the decission was made to do this. I can't find
it in the mailing list.
It probably started on p6i with Dans post: More sub/method call
stuff
Yeah,
# New Ticket Created by Clinton A. Pierce
# Please include the string: [perl #22718]
# in the subject line of all future correspondence about this issue.
# URL: http://rt.perl.org/rt2/Ticket/Display.html?id=22718
In this code:
.sub _main
.local string source
I'm not yet sure whether it's worth having engine support for
specific exception type checking
I think we would have:
- Exception handler = Continuation
- Exception object = a new class of some type[2]. When the system throughs
an exception, it would attach 2 properties to the
This is more of a language thang, so I've redirected your message
there [here].
The most fundamental feature throwing an exception is that it transfers
program execution from the call site. Allowing the caller to resume
execution at that site is a very dangerous form of action at a distance.
Sorry, the example was unnecessarily long.
After a quick reading of this, I'd have expected the value of f at the indicated
point to be 1, but instead it's 2.
.local int f
.sub _main
.local int x
.sub _foo1
f=1
x=2
Consider this Perl 6 code:
sub refinc($var) {
my $myvar = $var;
$myvar += 1;
}
If you pass an integer in here, it should do nothing. However, if you
pass an object with an overloaded += in, it should have the
side-effect of adding one to that object. It's just a
Luke Palmer [EMAIL PROTECTED] wrote:
Consider this Perl 6 code:
sub refinc($var) {
my $myvar = $var;
$myvar += 1;
}
If you pass an integer in here, it should do nothing. However, if you
pass an object with an overloaded += in, it should have the
side
So, now that we're using CPS, will there be a standard way of seeing
what the call stack is (for purposes of debugging/Ccaller/c.)? Is
it just a matter of looking in P0 and then P0's P0, and so on? Or
will that croak in certain cases?
Luke
This patch implements optional arguments for the longopt subsystem,
and modifies imcc to use them.
Luke
Index: longopt.c
===
RCS file: /cvs/public/parrot/longopt.c,v
retrieving revision 1.4
diff -u -r1.4 longopt.c
--- longopt.c 27
I'd like to go about implementing [Perl]?LazyArray and LazySequence
pmcs, possibly with a TiedArray (and Infinity) in the interim. I have
a few semantic questions, but first, here's what I have in mind:
LazySequence: Manages individual lazy sequences like 1..Inf (or
601 - 700 of 1293 matches
Mail list logo
