ically
have "multi rule" if you declare parameterized rules, though most rules
take the same argument list. A set of "multi macro" would presumably
dispatch at compile time, but it's not clear how the various "is parsed"
rules would interact.
Larry
ic) or some other flag to remove the
: implicit scoping. Would that be a saner default? :-)
Maybe that's what q:code(:COMPILING) actually does? Or has as an
additional side effect? Hmm...
Larry
thing you put on the actual reference
taking syntax... And if the latter, which syntax?
Larry
On Mon, Mar 13, 2006 at 08:28:46AM -0800, Larry Wall wrote:
: The default answer should probably be yes,
Or maybe not... After all, the main point of taking a reference is
to nail down particulars so you can bypass the identification phase
next time and deal directly with your object (or proxy
On Mon, Mar 13, 2006 at 09:37:47AM -0800, Larry Wall wrote:
: On Mon, Mar 13, 2006 at 08:28:46AM -0800, Larry Wall wrote:
: : The default answer should probably be yes,
:
: Or maybe not... After all, the main point of taking a reference is
: to nail down particulars so you can bypass the
On Tue, Mar 14, 2006 at 06:36:22PM +0100, Ruud H.G. van Tol wrote:
: Or POD-ish.
Or POD-ish is what A2 proposes. I still like
=begin FOO
...
=end FOO
Larry
.
So it'll be easy to drive a cultural wedge between yourself and the
rest of humanity, as long as you describe it to the anthropologists...
That goes for Perl 6 in general too.
Larry
we will always
be inventing limited machines at the low end of the size scale.
It is unlikely that the first nano-bots will run Linux...
I don't really have much wisdom on all of this. But hey, that's
why I'm letting other people design the threading, so they can take
the blame. :-)
Larry
second thing is much harder for me to pretend to implement
Maybe have the debugger .wrap all CATCH blocks?
Larry
opefully as lazy as the underlying object allows
in reverse. (To reverse an array in place we'd use .=reverse.)
Larry
d MODE, all(@files) -> $oops {
???;
profit();
}
Larry
On Sun, Mar 26, 2006 at 02:40:03PM -0800, Larry Wall wrote:
: On the original question, I see it more as a junctional issue.
: Assuming we have only chmod($,$), this sould autothread:
:
: unless chmod MODE, all(@files) -> $oops {
: ???;
: profit();
: }
Except that junctio
ge to restore yourself to your current value"
and nothing more. (Well, plus the notion that, when applied to a
mutator, the save/restore instruction is passed on to the mutatee to
save itself before the mutation, not after.)
The p5-to-p6 translator will turn
local $x;
into
temp undefine $x;
Larry
Recently I had time to think about the $ symbol we use in Perl.
I think Perl has been using the USD symbol for too long, and I'm now sure
that it's time to replace it. After some research I came to the conclusion
that the best fit is the euro symbol (€).
So, spread the word, Perl 6 will requir
On Sat, Apr 01, 2006 at 03:11:27PM -0800, Larry Wall wrote:
:
:
: Recently I had time to think about the $ symbol we use in Perl.
:
: I think Perl has been using the USD symbol for too long, and I'm now sure
: that it's time to replace it. After some research I came to the conclusi
keyboard.
For those of us without ASCII keyboards, it'd be a lot easier to type ⾦.
Larry (the real one (really! (heh, heh)))
On Sun, Apr 02, 2006 at 02:15:46AM +0200, Ruud H.G. van Tol wrote:
: Uri Guttman wrote:
:
: > When cast into an array, you can access all the positional
: > arguments; Into a hash, all named arguments; Into a scalar, the
: > invocant; Into code, into slurpy nameless block.
:
: The las
der whether we can set up some automated way to at least
detect such accidental de-unicodification. Even just knowing the maximum
intended codepoint in the message might help detect most such errors.
Or even just knowing that *any* characters above 255 were intended...
Larry
, at least this week...
There's some discussion about whether it should simply be:
method as (Str) {...}
method as (Int) {...}
maybe with an "is deep" thrown in for good measure, but we haven't
quite got there yet.
Larry
On Mon, Apr 03, 2006 at 08:24:51PM -0700, Larry Wall wrote:
: There's some discussion about whether it should simply be:
:
: method as (Str) {...}
: method as (Int) {...}
:
: maybe with an "is deep" thrown in for good measure, but we haven't
: quite got there yet.
d a Set type, as well as ASCII representations
like (*) and (+) for the set ops so we don't force anyone to use
Unicode prematurely. Unfortunately these have not found their way
into the synopses yet, as far as I know.
Sorry if this is a bit meandering--jet lag is interfering
constructively with my native dimwit...
Larry
(1,3),
(2,3),
(1,2,3),
)
Larry
based on enumerated sets. Oddly missing are any
Sets that are defined by rule. That would presumably take closures,
though I suppose one can attempt to enumerate the closures that have
to hold true and autothread through the calls to those closures...
Can Russel be far behind? :-)
Larry
On Tue, Apr 04, 2006 at 11:23:14AM -0700, Jonathan Lang wrote:
: Larry Wall wrote:
: > On Tue, Apr 04, 2006 at 11:02:55AM -0700, Jonathan Lang wrote:
: > : Will perl6 Sets include set negation and/or a universal set? In
: > : effect, an internal flag that says, "this set contains
th a language that can parse line noise.
Another option would be to duplicate the . on both ends of the whitespace
when you want a delayed postfix:
say.
.foo.
.[32];
Somebody please point out all the downsides to this approach. But you're
only allowed to count "I'm not used to it yet" once. :-)
Larry
()
foo .1
.foo .bar
.foo .()
.foo .1
I'd rather have a rule you don't have to think about so hard. To me
that implies something simple that let's you put whitespace *into*
a postfix without violating the "postfixes don't take preceding
whitespace" rule.
Larry
etroactive guessing games.
It's possible the $x... infinite range operator could be recast to
something else like $x..* or some such, but that's a niggle compared
to the enormity of cleaner parsing.
Larry
On Fri, Apr 07, 2006 at 10:07:55PM +0100, Nicholas Clark wrote:
: On Fri, Apr 07, 2006 at 01:11:15PM -0700, Larry Wall wrote:
: > On Fri, Apr 07, 2006 at 01:04:38PM -0700, [EMAIL PROTECTED] wrote:
: > : +The long dot form of the C<...> postfix is C<0. ...> rather than
: > : +C
On Thu, Apr 06, 2006 at 05:36:56PM -0600, Luke Palmer wrote:
: On 3/27/06, Larry Wall <[EMAIL PROTECTED]> wrote:
: > The p5-to-p6 translator will turn
: >
: > local $x;
: >
: > into
: >
: > temp undefine $x;
:
: Are you sure that that's not:
:
: undef
Seems a lot more benign than the previous forms
of lookahead though. Definitely easier to parse visually, I think.
Larry
and
is the same "square" shape on the front, and could easily be confused
with a normal line-ending comment.
Larry
foo()
or
$x.#[ comment
]foo()
But I think it's just a little too easy to write #x by accident and
get x as the delimiter, so I'm leaning towards, .#// still.
Larry
On Fri, Apr 07, 2006 at 08:11:04PM -0700, Jonathan Lang wrote:
: Larry Wall wrote:
: > I really prefer the form where .#() looks like a no-op method call,
: > and can provide the visual dot for a postfix extender.
:
: Although inline and multiline comments are very likely to be u
ever"
: context. This is best demonstrated using an example:
:
: my $x = grep { ... } @list; # returns count
I think that's already "whatever context". $x contains the resulting array.
It's only if you later say +$x that you'll get the number of elems.
Larry
:
=begin UNUSED
sub foo
{
if foo { }
}
=end UNUSED
And I don't really care if that's not what people are used to.
The whole point of Perl 6 is to change How Things Work.
Larry
On Tue, Apr 11, 2006 at 12:54:50PM +1200, Sam Vilain wrote:
: Larry Wall wrote:
:
: >On Tue, Apr 11, 2006 at 12:26:13PM +1200, Sam Vilain wrote:
: >: This does mean that if you comment out blocks with s/^/#/, you mess up on:
: >:
: >: #sub foo
: >: #{
: >: # if foo { }
:
Plus it won't interfere
visually with your ### blocks. And it has the additional advantage
of keeping your tabs lined up. :-)
Larry
On Tue, Apr 11, 2006 at 01:21:32PM +1200, Sam Vilain wrote:
: Larry Wall wrote:
:
: >: But this fragment dies:
: >:
: >: #sub foo
: >: #{
: >: # bar { } unless baz
: >: #}
: >I don't see how that's different at all from the first example.
: >
: >
:
examples. In the second case you could
omit the "return" since you're not returning a bare block, so it's
not ambiguous. (The other difference is that the explicit sub form
allows you to return from within the closure.)
Larry
tely like
an integer shift would. But if you then used it as an integer,
it would truncate it, so maybe that's okay...)
Larry
wedgey applications that wouldn't work
about as well by starting the wedge with $x. .y instead of $x.y.
Larry
of that, though
perhaps not as efficiently.
Larry
ad will explode:
given Sig { when Cap :{...} {...} }
given Cap { when Sig :{...} {...} }
especially if anyone suggests that
given Sig { when Cap {...} }
given Cap { when Sig {...} }
should implicitly bind over the scope of the inner block.
Larry
$a, $b, $c;
is still an error, generally caught by the fact that $b hasn't been declared.
I'm sure I've left out something important...
Larry
uot; (short for "production") or "words". Even earlier
versions made ordinary "rule" have these semantics, but then it was
too confusing to talk about rules in general. I was very happy when
I thought of splitting the concepts yesterday.
I will think about that some more today. Consider "parse" a placeholder
for the concept of a plain old ordinary BNF rule.
: > +With C<:global> or C<:overlap> or C<:exhaustive> the boolean is
: > +allowed to return true on the first match.
:
: Nice, nice, nice! Makes things *much* simpler for PGE.
I don't see much point in not having rules be as lazy as possible.
Larry
undant since the ||= returns its current value.
Larry
On Fri, Apr 21, 2006 at 03:15:12PM -0400, Uri Guttman wrote:
: oy! the habits to be broken and relearned!
Habits are no fun unless they're either good or bad.
Larry
r it knows the context upon binding.
And then if you really want to interpolate all the iterator values
as arguments you'd have to say [EMAIL PROTECTED] or some such. But you could
also
intepolate only the first argument as *$$fh.
No decisions yet, but you only asked for Thoughts. :-)
Larry
ore the key for some reason, you can always
set .pos to $.beg, or whatever the name of the method is. Hmm,
that looks like it's unspecced.
Larry
only_after_foo ($isparsed) {
< $ >> <$isparsed>
}
Larry
On Mon, Apr 24, 2006 at 08:00:55AM -0700, Larry Wall wrote:
: If you want to reset to before the key for some reason, you can always
: set .pos to $.beg, or whatever the name of the method is. Hmm,
: that looks like it's unspecced.
I'm wrong, it's already specced as .from and .
On Mon, Apr 24, 2006 at 06:58:04PM -0700, Jonathan Lang wrote:
: How do you define new adverbs, and how does a subroutine go about
: accessing them?
Adverbs are just optional named parameters. Most of the magic is in
the call syntax.
Larry
On Mon, Apr 24, 2006 at 08:30:04PM -0700, Jonathan Lang wrote:
: Larry Wall wrote:
: > Jonathan Lang wrote:
: > : How do you define new adverbs, and how does a subroutine go about
: > : accessing them?
: >
: > Adverbs are just optional named parameters. Most of the magic is in
: &g
convention. If I had to
guess, I'd say it's actually quite likely to smartmatch by 6.0.0.
Larry
t falls out
of Hash syntax, unless you like writing $x ∈ $bag instead of $bag{$x}.
Presumably we could make both work.
I'm just not sure every type we think of really needs a new name...
Larry
en" does).
:
: Then your mutable set is:
:
:my Hash of Unit $set;
Hmm, well, if values are just single-element subsets, then:
my %set of 1;
my 1 %set;
Larry
On Sat, Apr 29, 2006 at 05:15:08PM +0200, Juerd wrote:
: Larry indicated that changing the long dot would have to involve
: changing the first character. The only feasible solution in the "tiny
: glyphs" section was the backtick. I refrain from explaining why that
: will widely be consid
On Sun, Apr 30, 2006 at 06:33:01PM +0100, Nicholas Clark wrote:
: On Sun, Apr 30, 2006 at 09:58:21AM -0700, Larry Wall wrote:
:
: > Neither of those are currently legal in infix position. The backslash
:
: > Backslash also has the advantage of making sense to a C programmer:
: >
: &
in a context that implies discrete increments, such as counting in
list context. But if you say
$x ~~ 1.2 ..^ 3.4
it is exactly equivalent to
1.2 <= $x < 3.4
The main point of context is to avoid an explosion of types.
Larry
#x27;re planning
to store them in a particular spot. Floaters win on both counts.
Larry
give the hash a shape with a key type that is easily
coerced from the input types, I suspect. Hash keys could probably
afford to do an implicit .as(KeyType) even if the current language
were to disallow implicit conversions in general.
Larry
of a convenient way of expressing scans in Perl 6.
:
: I'm probably not thinking hard enough, so if anyone can come up with an
: implementation please give it :) Otherwise, how about we add this to
: the language?
Maybe that's just what reduce operators do in list context.
Larry
nd, if people are going to invent simplified
macro syntax anyway, I'd rather there be some standards.
Larry
it to mean that, and it's sufficiently
orphaned that few people are going to complain about impressing it
into forced labor. And, in fact, the larger cultural meaning of
token implies that it's something simple that represents something
complicated, as in "a token of our appreciation."
Larry
y provisional, a Foo would
have to resolve to a sub Foo () or a sub foo ($x?) by the end of
the compilation.
Hmm.
Larry
() function.
Which all probably means that we're still better off distinguishing quote
macros from "word" macros so that the intent is clear. A quote macro would
have no doubt: qX() always means to call the qX function, not the quoter.
Larry
ot;pattern matching". If
: we're going to be anti-pedantic, let's be consistently anti-pedantic. :)
Consistency is the hobgoblin of small languages.
Larry
On Fri, May 12, 2006 at 01:50:59AM +0200, Ruud H.G. van Tol wrote:
: Allison Randal schreef:
: > larry:
:
: >> Changed :words/:w to :sigspace/:s and invented ss/// and ms// (or
: >> maybe mm//).
: >
: > I keep expecting 'sigspace' to have something to do
: that impossible nowadays?
Considering we still have * for Whatever, I don't see any problem with
letting ** still mean MultiDim of Whatever. In fact, we've made it easier
now. I was deleting it from S03 only because it's not an argumentless operator
anymore, but a lowly term. Probably about time to revisit S09 again...
Larry
e down into the ::DEFAULT subpackage of
the module, and it hopefully can become very efficient to import a
prepackaged set of symbols as a lump.
If this isn't answering what you were asking, please ask s'more,
and I'll try to reply when I'm not busy having a grandbaby.
Larry
false.
The purpose of all this is to support prototype-based programming as
well as class-based programming. Assuming either one or the other
(in the absence of appropriate declaration) is a kind of encapsulation
violation of the .meta interface.
Larry
s in the original, sometimes the
official story needs a bit of tweaking. But for now the Package of Oz
is great and glorious, and doubtless you should be quaking in fear. :)
All that and several bucks'll get you a Starbucks...
Larry
You should not need "my" on the right side of a ->. Also, you should
be able to write $arg_for for constant subscripts.
Larry
On Tue, May 23, 2006 at 05:32:22PM -0700, Ovid wrote:
: Er, and the first loop is better written as this:
:
: for %buckets.values -> my $arg_for
7;t really be smart about one side
without also being smart about the other side.
Larry
On Wed, May 24, 2006 at 06:54:53PM +0300, Gabor Szabo wrote:
: if eval "command" fails, where can I get the error message ?
:
: aka $@ in P5 ?
All error variables have been unified into $!, so it should show up there.
Larry
This topic may be better suited to perl6-language, unless you consider
its denizens to already be self-selected against logic programming. :)
Larry
Synopses are kept up to date. See
: >http://dev.perl.org/perl6/doc/design/syn/S05.html
:
: Ah! I see. Thank you. This is extremely important information. I'd
: like to see it in large red letters across the top of the exegesis
: page, for example.
Done, hopefully will propagate to dev.perl.org within 6 hrs.
Larry
On Tue, May 30, 2006 at 07:56:40AM +0100, Michael Mathews wrote:
: Strangely %q<$n>.push($v); doesn't
: work, but %q.{$n}.push($v); does. What's the difference?
The first is equivalent to %q{'$n'}.push($v).
Larry
e for different kinds of users.
"Here's the ISP distribution, there's the bioperl distribution."
One thing we could do better than the Linux model is specify how
different distributions must stay compatible and interoperate with
other distributions so that you can load several of them at once.
Larry
later when the transaction is committed, I suspect.
Larry
a bit odd to use a construct for its syntactic sugar value but
take away its semantics...
If you just need ordering, this (or something like it) should serialize it:
print $_.() for @_;
Larry
, but if some of the value calculations that can blow
up are guarded by "or" conditions, then you've got a problem.
We'll definitely need to provide some knobs for the user to turn to
control how much refactoring is attempted.
Larry
is missing from the specs...
Larry
n the other hand /nani/ means 'what?',
which might work a little better for a wiki.
Larry
an interface (or set of interfaces), and
an object is presumably allowed to change how it responds to that interface,
as long as it doesn't violate The Contract.
Larry
when True {...}
}
should work that way, on the assumption that Bool is just an enum.
But Bool is really a role, and basically any type does Bool. So that
tends to argue for either comparing $a == $b to $bool or illegalifying
it somehow when ambiguous.
Larry
eptions, but we're just not
gonna do that anymore. It makes much more sense to unify them, I think.
The latest version of S04 documents how all this is expected to work,
in particular the notion that warnings are just considered control
exceptions so that they bypass most CATCH blocks but can be managed
via CONTROL blocks.
Larry
On Sun, Jun 18, 2006 at 05:18:52PM +0200, A. Pagaltzis wrote:
: Maybe TheLarry can enlighten us… :-)
We already have the operator you want. It's spelled C. :-)
Larry
On Sun, Jun 18, 2006 at 07:27:57PM +0200, A. Pagaltzis wrote:
: * Larry Wall <[EMAIL PROTECTED]> [2006-06-18 19:05]:
: > On Sun, Jun 18, 2006 at 05:18:52PM +0200, A. Pagaltzis wrote:
: > : Maybe TheLarry can enlighten us… :-)
: >
: > We already have the operator you wa
apping in {...} is the generic
method of suppressing comparison to $_, though ? and true() also work
for that.) You can always write
given $boolean {
when .true {...}
when .not {...}
}
to mean the other thing. Or horrors, maybe even just use an "if"...
Larry
no longer
functions as an adverb, at least in terms of looking for a subsequent
argument. I will attempt to clarify the distinction between quotes
and ordinary macros. Thanks.
Larry
3), how is C parsed? (Notice
: the space before parens).
:
: Would that be parsed as invalid function-call (i.e. syntax error) or
: valid quote?
It's a valid quote.
Larry
s() may cover the common cases.
It's also possible that some ~~ variant also binds a capture to
an interpolation. That would have the advantage of working in
either order.
: Some alternatives are idiomatic combinations of interpolation and .as(),
: Perl6::Form forms, and custom quote operators/adverbs.
:
: So, any takers?
We don't need any takers, we need any givers. :)
Larry
03d')"
But that's backwards from Python's % operator. Actually, I think I like
the Perl way better for single patterns... :)
Larry
On Sun, Jul 02, 2006 at 09:26:20PM -0400, Bob Rogers wrote:
:However, I notice that S04 doesn't explicitly specify the dynamic
: environment for anything evaluated in a CATCH block.
Does now. Thanks!
Larry
use **perl5::DBI;
much like we allow *Foo as short for GLOBAL::Foo.
Larry
On Thu, Jul 06, 2006 at 09:09:08AM -0700, Larry Wall wrote:
: use **perl5::DBI;
which, if you don't like the two-character form, you can spell:
⁑perl5::DBI
:-)
Hmm, hmm, speaking of sanity, how 'bout user-defined sigils and twigils:
sigil ¢ = Capture;
twigil ¬ =
x27;t imply that that's the entire
eventual parameter list. That is, it mustn't assume that the supplied
parameters are delimited with semicolons in the receiving signature.
So for purposes of implementation, it does behave merely like a default.
Go figure...
Larry
On Sat, Jul 08, 2006 at 06:04:40PM -0400, Aaron Sherman wrote:
: I've gathered my ducks in a row, used the feedback that I've gotten so
: far, and I think I'm ready to officially update S29. For that I need two
: things:
:
: 1) I'd really like Larry to glance over the change
think about it
whenever there's a lack of whitespace. It would be nice if :foo{}
were the only exception to that.
For similar reasons, I'm also tempted to say that if() is always a
function call, because it looks like one.
Larry
901 - 1000 of 3629 matches
Mail list logo
