e of a
: > powerful meta-model. Quite the contrary I want to see Perl 6 have a
: > meta-model more powerful and accessible then CLOS. I see it as a
: > necessity for a language that plans to truely scale in the future.
: >
: > What I do question is the usefullness of having bare class
ndirectly quantified and therefore is an array of
: match objects. We should probably reword it, or get a clarification
: of what is intended. (Damian, @Larry: can you confirm or clarify
: this for us?)
I believe that was the intent, but I'll defer to Damian on the wordsmithing
because I'm a bit out of sorts at the moment and it'd probably come out
all sideways.
Larry
of true intelligence, it is good to consult with
: someone of good sense. -- Hagakure http://bereft.net/hagakure/
It's not entirely clear to me that we should trust the advice of someone
who was prevented from committing seppuku only by edict of Tokugawa. :-)
But the scary part about that quote is that it seems to be saying that
if you have true intelligence you don't need good sense.
Larry
s:g/valid\?/currently reserved/, but yes, that's pretty close to the current
state of affairs. You could remove the ? from Foo[$bar], I think.
Larry
For the moment this doc is still in pugs/docs/AES/S29draft.pod.
This is all still quite negotiable. I'm particularly not settled on
the character type names yet.
[Please split replies to separate threads.]
Larry
Index: S29draf
ot;eigenmethod" to I should also change "an"
: to "a":
:
: +Such a I is always delegated to C<.meta> just as
:^
:
: Small thing, but someone will mention it eventually anyway.
Fixed, thanks.
Larry
for yourself. On the other hand, your current implementation is
perhaps TCLishly string oriented. But you want to call out to other
functions that aren't "Str filtered". You can declare
sub foo (--> Any) returns Str {
return whatever();
}
and force Str context on whatever() without promising that you're doing
that do everyone else.
Larry
-> type
rather than the "returns" type. Or maybe there's no distinction
for non-subs, but it seems nice to associate "returns" with "return".
Larry
On Thu, Feb 23, 2006 at 02:48:46PM +, Nicholas Clark wrote:
: Would it be better to do that automatically with svn tag expansion?
Yes, it would. Feel free, I'm not very svn-tag-expansion-aware yet.
Larry
On Thu, Feb 23, 2006 at 09:26:49AM +0100, TSa wrote:
: HaloO,
:
: Larry Wall wrote:
: >Um, I always thought that "is reserved" in a spec means "we don't have
: >the foggiest idea what we'll do with this, but we have a suspicion
: >that if we let people use this
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
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 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
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
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
and
is the same "square" shape on the front, and could easily be confused
with a normal line-ending comment.
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
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
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
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
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
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
of variable($x) is Object, however.)
The behind-the-curtain polymorphic magic you're thinking of is really
handled within the various dispatchers, which call various methods
as if they were subroutines rather than methods. That's how the
"lying" happens, generally.
Larry
ize the records.
The sort routine can decide whether it'll be more efficient to do
various transforms or maneuvers based on the declarative syntax of
the signature.
Then $a eqv $b and $a leg $b both just default to a signature that selects
everything.
Larry
On Thu, Jul 13, 2006 at 12:50:19PM -0700, Larry Wall wrote:
: Then $a eqv $b and $a leg $b both just default to a signature that selects
: everything.
Though arguably P5's string-forcing semantics should be C and the
polymorphic semantics should probably be C.
Larry
;~~>($x)
assuming that the $_.foo($x) SMD eventually fails over to foo($_,$x) MMD.
But that doesn't seem to be much of an improvement over "when $x".
Larry
e semantics where it's not likely to be
confused with English.
Anyway, that's just another reason for going slow on throwing in the
negated versions.
Larry
On Thu, Jul 13, 2006 at 10:19:24PM -0600, David Green wrote:
: On 7/13/06, Yuval Kogman wrote:
: >So, Larry assisted by Audrey explained the purpose of === vs eqv vs =:=.
: >It makes sense now, but I still feel that as far as ergonomics go
: >this is not perfect.
:
: I think I unde
ainer's elements.
But I'll leave that up to the implementors. :)
Larry
n particular which failure modes
can give very good error messages like "Current line misinterpreted
as statement modifier, so previous line's } needs to be }; instead".
Or "Current line misinterpreted as statement, so previous line's }
needs to be }\ instead". And how often an ambiguous trailing {...}
might accidentally occur in a conditional expression...
It ain't easy. Maybe we should just make statement modifiers uppercase
and burn out everyone's eye sockets. :)
Larry
1101 - 1200 of 3168 matches
Mail list logo
