Hailo

 view release on metacpan or  search on metacpan

t/lib/Hailo/Test/TimToady.trn  view on Meta::CPAN

those just calculate the value at BEGIN or FIRST time, but the assignment is still at execution time.  If you want it to happen earlier,
you have to use "state $foo = " or "constant $foo ="
which imply FIRST and BEGIN time.
traveling and travel are both nouns, technically
you can also use "my $counter is begin(...)"
I outtagmemificated...
that one is just a progressive verb.  but "require travelling" is a gerund according to the high-school English teacher.
you can't argue with high-school English teachers...
the travelling is what gets to me...
the doubling of 'l' in travelling also gets to me...
but then, so does the non-doubling...
neither way looks right to me anymore.
the perils of being intercultural.
another one    ^^^^^
s/  / /
or we could just pronounce it with the emphasis on the last syllable, which would justify doubling the 'l'.
unless we also lengthen the 'e', in which case it would be one 'l'.
no state happens at FIRST time.
constant happens at BEGIN time.
we don't really have an INIT time declarator.
arguably our could do that, but people are used to assignment semantics there from P5.
some speculation in p6l that we should write labels as Lines: instead of LINES: to prevent that confusion.
hi everyone!
I just proposed .#() as embedded comment and as replacement for "long dot", which seems like a simplification.
realizes that all the time...
audreyt: which talk are you giving now?
and have you finished writing it?
(obviously not...)
=:= Larry Wall?
I certainly don't feel like a readonly alias...
maybe I just delegate to myself.
Nah, I'm so bad at delegation that I even delegate my delegating to other people.
never stopped you before.
just give 'em a little break in the middle...
sure
er, good question.  they have it up somewhere in .il
hang on...
http://wall.org/~larry/StumpIL.ppt
that's what I used in .il
so should work, if you're recent enough
OOo++
bye
we've been de-takahashied...
yup
yup
but the takahashified version of my stump speech is even more cryptic.
please tell me it's not a reference back to #perl6...
figgers
yep.  One of these centuries I'll have to come up with a new talk.
Actually it keeps mutating over time.
Actually, I come up with a new talk every OSCON.  It's everyone else gets the same talk.
'nite Juerd.
Though arguably all my OSCON talks are the same talk too...
Basically I never sign up for talks I have to write the abstract of in advance.
there's got to be some advantaget to it somewhere...
my throng of female groupies I can count on the fingers of one hand, and that's about all I'm allowed to do with 'em. :)
who says mine aren't?
Gloria tends to transcend groupiehood in various ways.
have you seen the Pugs Manifest from Audrey?
we shoulda put a link to it...
I'm busy revising S02 again, and it looks like it's working out very nicely.
Particularly since we still get a shorthand . . that is taken to be equivalent to .#. .
The other comments are naturally defined to make the "extra" newline into the whitespace.
So #... only extends *to* the newline at the end.
and =begin doesn't hide the newline before it.
or actually, ". ." is equivalent to ".#. .." so it still does the "long dot" trick visually.
have just checked in new S02.
pmichaud: see newest S02?
'bout 15 minutes ago
yes.
also have a response to the #. proposal queued, but my mailer is not sending right now.
I prefer the "shape" of .#() as a pseudo-method call.
looks more distinctive too in isolation
#. is too square on the front, and easily confused with plain #
also, I think $x# looks too much like the # is part of the $x.  it really need the dot in between.
And I just like the it looks like # is the name of the method in .#()
*that
you just write that $x.    .foo() now.  ". ." is short for ".#.  .."
is there.  when it's not, use .#[]
you almost always use "long dot" for lining things up, so there's redundant dots all up and down.
azuroth: no, that would destroy ###################### blocks.
me too.
cost me a nap worrying it though...
mostly residual jetlag, probably.  have to get up at 5am tomorrow to go down to San Diego and give a talk...
I do have many phases though. :)
dunno.  haven't scheduled an Australia phase yet.  I think I was supposed to come during my mid-life crisis, but my mid-life crisis turned out to be a rather pitifully small thing, as mid-life crises go...
all I did was scrap my life's work and start over...
Maybe with a quantum computer refactoring can be sped up...
Just call any(=io("*.rfc")) and see what pops out.
not any more
all places start with 'a'
do, or do not.  there is no try.
oopsie
?eval any(1,2) > 1
consistent, I'll give it that...
?eval all(1) == 1
?eval all(1,2,3) == 1
?eval all(1,2,3) != 4
?eval one(1,2,3) == 1
that's also broke
audreyt: what do you think of rxen default to backtrack, rules don't?
backtracking almost never makes sense in a parser.
if $result == bool::false { say bool::false }
yes, any(@number) makes a junction.
but it's a list operator, so Juerd is right, you need the parens.
or @number.any == ...
that one's probably okay, though in p6 rules it'd be better handled with a lookahead on an ident.
yes.
well, it still has to return both the "ident" and the => tokens somehow, I presume...
but yes, the p5 lexer would certainly commit at that point.
and for P6 we've said that => absolutely quotes any bare ident on its left.
even if it's a keyword.
so it was basically taking a continuation on every identifier before...
we aren't allowed to have types unless they're already declared, so how can it be deciding that sub is a type?
then we still recognize sub as a declarator first...
gotta have a few reserved words...
and surely declarators are about as reserved as they come.
No, but expecting it to work in "my sub" should be without saying "my ::sub".
I have no problem with making people go through sigilish contortions if they want to declare things that are the same name as declarators.
?eval my my $foo;
?eval my my my my $foo = 1;  $foo;

t/lib/Hailo/Test/TimToady.trn  view on Meta::CPAN

so as long as the same rules are called, it doesn't matter so much if the trees are different
but that approach would not be quite as safe as directly constructing AST
so yes, I'm hoping for convergence there
or maybe there's some common AST form that each implementation can transmogrify into its own form
pmurias: correct
thunk &
rhr: no, formal parameters can't take subscripts
mncharity: not exactly.  MY should give a view of all lexically scoped declarations including "our" and "state"
arguably it's misnamed
also, it doesn't fallback to GLOBAL under strict
(or do the package CANDO lookup either)
under strict, if it's not lexically declared or imported, it's not visible
you can certainly apply subsignatures to array arguments, so there's doubtless some way to work it so the nth element gets bound to a particular variable name, but subscript notation doesn't have much to do with it on the formal end
you can match a signature to any individual listy parameter using [$a,$b,$c]
so $c is by definition the 3rd element
see S06:1328 "Unpacking array parameters"
lunch
&
Auzon: you have to have a comma after map's block, unlike in p5
[particle]: skip does not require a block
and you can leave out the 1 on the "1 skip"
if you say 3 skip a block only counts as 1
I prefer "hey you!"
hey me
a statement counts as starting at a line with "is" et al, and terminating with a line with  ; (and optional comment)
I finally got my pugs smokes working again by skipping the tests that spat out malformed utf-8
we probably need another verb in fudge like "inline" so we can just insert code to call "skip_rest" and such
I made fudged files end with exit(1) so they come out "dubious" despite passing :)
what version of ghc?
(I use svn so can't help with darcs)
yow
still at 6.6.1 meself
[particle]++
It's actually quite fun to watch rakudo following in pugs footsteps wrt testing and development
it's a concrete example of the good kind of cross-fertilization
and a sign that we can use our differences as a strength rather than a weakness
anyhoo, thanks for helping with fudge
zzz &
you either want to drop the 2 or the block there
the block only counts as 1 skip
probably still need a way to say the following should be multiplied by N for loops and such
maybe I should force the count on a block to be interpreted that way
but I still think it's an attribute of the block, not the skip command
since it's shared by all platforms
maybe a #?all: scale 5
or some such
I'll think about it overnight.
meanwhile, it really doesn't matter so much if the count gets off
well, didn't get a nap today, so really need to thunk...
zzz really &
hmm, does that work for native types, I wonder...
well, you need to have a representation of the bits somewhere, and there's little point in duplicating if you don't have a machine code that inlines and forces indirection
instead
and as long as you keep your readonlyness straight, it works
well, it was easy enough to change them in Fortran
the Internet is a big place
it's possible that there are universes in which Perl 6 is done already, and maybe the Internet leaks between universes.
sorry, he's rocket lee in that universe
it's a strange quirk of english that jets aren't rockets, but rockets use jet propulsion
we'll release as soon as we get up to about 40,000 passing regression tests.
so you'd better get busy :)
to the first approximation, a capture is just a list of generators
some of which are marked as invocant or named, but to begin with they could just live in a list
and the methods could comb them out of the list on demand
well, $ @ % & are essentially just methods too
I don't see why they have to return containers
they're just context
no, it returns an item
and @ returns a list, not an Array
sure, but 1.STORE fails
only in the sense that everything is an object
and all objects are containers
presumably FETCH would be a noop on a nonScalar item
you only need a Scalar when you have an lvalue, not an rvalue
$foo = 42 requires a Scalar on the left
if you say $foo := 42 then $foo isn't in fact a Scalar anymore
and $foo = 1 will fail after the binding
just like Array or Hash, but not needing a subscript
that's for creating an unbound call?
seems reasonable; the syntax is designed so that you can sort out the inf/pos/named at compile time
.item .list .hash are the corresponding context methods
(and .slice is a variant of .list)
well, sure, low-level binding needs to do whatever will be efficient
and even when binding to *@_ and *%_, those proxies are only the *remaining* args
so shouldn't be confused with @($capture) or %($capture)
you do probably need to be careful that you have a way of preventing eventual assignment to a formal parameter that isn't declared "rw", even if the actual argument is "rw"
but it's just something to be bear in mind
that's fine; is how all computers really work anyway...
well, most of them
there have been computers with fine-grained ro/rw attriubutes
sounds like you're on the right track
certainly you want the mechanism to be fast when it can be proven that a formal parameter cannot be written to
no point in protecting it if there's no threat
if protecting it implies overhead
have you thought about optimizing multiple dispatch yet?
depends on what you mean by native
certainly captures and signatures are at the top level just values
it's only by indirection that you get generators or containers
Signature and Capture are listed as immutable in S02
well, sometimes you have to box values
and most value types are punning with an identically named role
well, in a sense there is no int type
the type of int is Int
but with restrictions on storage
yes, Int is a role that can be mixed into make other RIs
but we can restrict Capture/Signature, or call 'em capture/signature, if we need to
you don't have to convince me--I want dispatch to be fast
the lowercase ones
we still might like a Capture role that can mix
for instance, into Match objects
but then you just have to unbox to capture
if you use it that way
maybe the original boxed Capture goes through the invocant if you don't have one.
maybe not
bbl &
lichtkind: optimal in which dimension or set of dimensions?
(it's primarily optmized for the visual dimensionh)
it's an unusual thing to want to do
and the triangle part of it is kinda pretty
yes, the left vertical and the backslash suggest a triangle
[\,] 1..10

t/lib/Hailo/Test/TimToady.trn  view on Meta::CPAN

rakudo: say 1,2,3 X 4,5,6
that one is right
so you're right, rakudo does know about list infix, but >>+<< isn't one
(yet)
colomon: actually, pugs did implement the multithreaded hypers at one point
holli: also, we have feed operators ==> and <== that work like pipelines for cell architectures
but those aren't implemented yet either
but basically any lazy lists could be constructed by a separate processor, as long as there aren't bad dependencies (side effects)
holli: sure, but lazy lists have to keep ordering, even if calculated out of order; clouds tend to be better for map/reducey things
as opposed to ComplexPerl? :)
ImaginaryPerl is a bit long to type
but I'd like both Perl 5 and Perl 6 to be real, so maybe NumPerl vs RatPerl
botrot
I thought llvm didn't really support C++ yet...
the ones in STD.pm are, more or less
to the extent that STD.pm is spec..
sprixel: $_ = 'foo { 1 + 2 } bar'; say $_.eval
sprixel: say 'foo { 1 + 2 } bar'
'is supposed to' is not, strictly speaking, a defined phrase in Standardese... :)
but yeah, more or less :)
thanks...I think...
I'll have to figure out someplace to put the couch, though...
I like the ^X^Cvi emacs command, myself  :P
in what way would this not be possible in a Perl 6 module?
or is it some other exotic language, like English?
hmm
and 'su' could be any of various things
cognominal: ~~ does not force its right hand argument to be a regex, so ~~ '\v
would be a string match
but \n should be matched by \v, oui
radkudo: say ?("\n" ~~ /\v/)
rakudo: say ?("\n" ~~ /\v/)
I don't think rakudo knows \x inside of character classes though
forgot the masak++  :)
bbl &
std: my Int constant pi of Num = 3;
std: sub foo returns Rat returns Cat {...}
forgot to remove the <typename>* from :constant...
std: my Int of Int sub foo returns Blob {...}
those aren't initializers
remember declarators aren't statements
and initializers are deemed to be initializers at reduction time of binding/assignment
if the left side is a declarator
that should carp about redeclaring Foo, I suspect
std: our constant Foo = 1; our constant Foo = 2;
hmm, so much for that theory
std: constant Foo = 1; constant Foo = 2;
hmm, works there
std: my constant Foo = 1; my constant Foo = 2;
std: our constant Foo = 1; our constant Foo = 2;
ah, rev change
before, Foo was considered a valid type
std: our Int constant Foo = our Int constant Foo = Foo;
declarators don't generally care whether the word they're declaring is a keyword
std: sub sub {...}
I don't recall every doing a distclean
*ever
testing a fix
that should fix it
so I can understand all the eu folks staying bundled up in their beds, but what's the excuse of all those hardy usians?  all out snowmobiling or somethin'?  :)
maybe they're all too busy hacking to waste time on irc :)
well, taking care of yourself is also important; we're in this for the long haul
the author of elf is a hare rather than a tortoise, and he's been haring off for a while now
only roles
but roles used as classes will attempt to pun themselves into a class
however...
std: class Foo[Int] {...}
std: rle Foo[Int] {...}
std: role Foo[Int] {...}
yes, Foo of Int is basically the same thing
yes, that could all be better written, but it sounds like you have it straight in your head
sigils are part of the name, and anonymous KeyHashes don't have a % in their name
except insofar as they are named by whatever the Hash key is
it's not like in Perl 5 where you have to play %{} tricks
well, it's coercion to Associative, really
we're still feeling out this business of coercing to a role, which tends to be dwimmy
unary + and ~ also turn out to be coercion to Numeric and Stringy, it seems
and in the case of Numeric, probably calls into the parser to figure out which kind of numeric to return
other role coercions might use a list of handlers, or some such
or maybe it can degenerate to a multi dispatch of some sort
"who most wants to turn this into something Foo-ish?"
it's probably only the from-string ones that are mediated by the parser
and coercion to Stringy is probably just coercion to Str for now, unless we want to make some things coerce to Buf
it is not clear how that pecking order should work
correct
but that is a bit of a bogus statement
that is a Hash that returns KetSets
*KeySets
makes more sense with $
or you can do 'my %foo is KeySet;'
or 'my %foo := KeySet.new;'
well, the $foo<TimToady>++ itself wouldn't return true the first time
but $foo<TimToady> would be true after that
since it's a postincrement
p6 specs NFG format, which naturally maps to arrays of integers, either unsigned if there are no strange characters, or signed if there are
where "strange" is defined as any grapheme not having a precomposed form
but Array[int32] and Array[uint32] can easily be optimized to smaller native types when the string is known to contain smallish characters
google for 'perl nfg' and you'll find a bunch of stuff
but it stands for Normalization Form G
which you won't find in the Unicode standard
it uses positive ints for any grapheme representable by a precomposed codepoint, and negative ints to represent lookup in a table for non-reducable graphemes with multiple codepoints
our original conception had a single process-wide lookup table, but I think parrot currently specs per-string
more work when you hit a negative "codepoint", but less vulnerable to DOS attack
but the idea is that Str is never represented internally in a variable-width format
those belong out in Buf types
so you can write all your Str algorithms with simple array indexing
that's the goal
which says UTF-32 is a good spot to start
or think of it as UCS-4
downgradeable to UCS-2 if there are no plane 1 characters
downgradeable to UCS-1 if there are no non-latin-1 characters :)
in the abstract, NFG is just a sequence of integers
it's really just NFC plus inventing more precomposed graphemes on the fly as necessary
and making sure they get translated back to the appropriate sequence of codepoints on output
the negative codepoints are allocated from -1 on down to keep the wordsize small if possible
but that's why your computer has multiple cores :)
yeah, always seems to me that it would be really easy to steal the unicore tables from Perl 5
but there seems to be a mental block against that
maybe we should take Perl 5's mktables and get it to emit P6 code that implements NFG
especially if done in a small additional CPU  :)
funny if our first feed operators actually come from an IO layer