»ö« Welcome to Perl 6! | perl6.org/ | evalbot usage: 'p6: say 3;' or rakudo:, std:, or /msg camelia p6: ... | irclog: irc.perl6.org | UTF-8 is our friend! Set by masak on 12 May 2015. |
|||
ShimmerFairy | Yeah, I'm not sure what's wrong. | 00:01 | |
m: class C { multi method M($go) { say "X" }; multi method M(Int $go) { callsame; callsame; callsame; } }; C.M(1) | |||
camelia | rakudo-moar a32c14: OUTPUT«X» | ||
TimToady | looks like a bug to me | 00:04 | |
AlexDaniel | ok | 00:05 | |
I'm already submitting a ticket | |||
smls | m: my $x = EnumMap.new("a", 1, "b", 2).list[0]; say $x; say $x.WHAT | ||
camelia | rakudo-moar a32c14: OUTPUT«a => 1(Pair)» | ||
smls | So EnumMap does not actually represent its entries as Enums as the design docs suggest? | 00:06 | |
AlexDaniel | m: sub foo { say 'X' }; &foo.wrap:{ callsame; callsame; nextsame; say 'y' }; foo; | 00:09 | |
camelia | rakudo-moar a32c14: OUTPUT«Xy» | ||
AlexDaniel | it is interesting how the code just keeps executing after nextsame :) | ||
TimToady | it's almost as if callsame and nextsame were reversed | 00:10 | |
ShimmerFairy | m: sub foo { say 'X' }; &foo.wrap:{ nextsame; say 'y' }; foo; | ||
camelia | rakudo-moar a32c14: OUTPUT«X» | ||
TimToady | except that wouldn't work either | ||
ShimmerFairy | AlexDaniel: it's actually because the 'callsame' is interpreted first | ||
skids | gist.github.com/skids/edac2cebdab5c6bd7641 # apply against GLR to get accurate error messages, for those hacking on it. | 00:11 | |
ShimmerFairy | my guess is that multiple call/next* don't get used correctly. | ||
(almost like using one of those functions exhausts the candidate list, or somethin') | 00:12 | ||
cognominal | A question about actions of match withing a <?before >. Please comment : gist.github.com/cognominal/9067d157b484fb7703c7 | ||
00:16
llfourn joined
00:20
llfourn left
|
|||
smls | TimToady: That whole "hashy" part of the type hierarchy (EnumMap, Hash, PairMap, QuantHash & co) is kind of a mess. | 00:21 | |
TimToady: The design doc in question (S32::Containers) feels muddled in and of itself (things like suggesting that Hash indirectly inherits from Positional); and Rakudo's interpretation of that spec seems scrappy and adds additional weirdness. | |||
Timtoady: Is there any chance some of those type names and their inheritance relationships can still be tweaked before 6.0? | 00:22 | ||
Would be a shame if the elegant and well-thought-out post-GLR set of listy classes, is accompanied by a jumbled set of hashy classes, in the big release. | |||
ShimmerFairy | smls: I agree, when mapping out a plan for a tutorial series I'd like to write sometime, the Set/Bag/Mix stuff were given their own heading. | ||
.oO(the Grand Associative Rejiggering -- GAR) |
00:23 | ||
smls | It would be very grand in terms of implementation effort neede, I think. | ||
00:23
laouji joined
|
|||
smls | Some renaming and rearranging mostly, while pretty much keeping the classes' current functionality. | 00:24 | |
s/would be/wouln't be/ | |||
ShimmerFairy | smls: I've gotten the feeling that the associative stuff beyond Hash is some special deeper area, with the only likely-seen part being the Set operators. Part of that is likely the fact that those associative types aren't used as much (at least in what I do), but I wonder how much is up to their current design. | 00:25 | |
skids | ahem. ReHashing... | 00:27 | |
:-) | |||
00:27
BenGoldberg joined
|
|||
ShimmerFairy | I personally like that the R in GLR is slowly becoming whatever it can be :P (and I hope to help in making that the case) | 00:28 | |
AlexDaniel | yea, finally | 00:29 | |
00:31
spider-mario left
00:32
yqt left
|
|||
TEttinger | Great List Rapoff | 00:37 | |
dalek | kudo-star-daily: 2280a8f | coke++ | log/MoarVM- (5 files): today (automated commit) |
00:38 | |
AlexDaniel | i | ||
m: say index 'yy', 'y', -999999999999999999999999999999999999999999999999999999999999999; | 00:39 | ||
camelia | rakudo-moar a32c14: OUTPUT«Nil» | ||
AlexDaniel | m: say index 'yy', 'y', -9999999999999999999999999999999999999999999999999999999999999999; | ||
camelia | rakudo-moar a32c14: OUTPUT«1» | ||
00:39
laouji left
00:40
laouji joined,
captain-adequate left
|
|||
smls | TimToady: I could dig into this stuff further and maybe come up with some form of RFC, but if there's no "political will" to change anything in that area anymore, I needn't bother. | 00:41 | |
00:42
laouji left,
laouji joined
|
|||
BenGoldberg | ShimmerFairy, GLR = (G)reat (L)ist whateve(R) | 00:45 | |
00:50
TEttinger left
|
|||
BenGoldberg | m: .say for index('yy', 'y', -1e34), index('yy', 'y', -1e35); | 00:51 | |
camelia | rakudo-moar a32c14: OUTPUT«Nil0» | ||
AlexDaniel | BenGoldberg: I've just submitted it: rt.perl.org/Public/Bug/Display.html?id=125784 | 00:52 | |
but it would be great to know why does it happen | 00:53 | ||
m: say split('', "a;b;c").perl; | |||
camelia | rakudo-moar a32c14: OUTPUT«("", "a", ";", "b", ";", "c", "")» | ||
AlexDaniel | empty strings? | 00:54 | |
ShimmerFairy | not sure if that's a bug or not, but if you're looking to split things into characters, you want .comb anyway. | 00:57 | |
AlexDaniel | I'm looking for a bug | ||
.oO(maybe there is another function to do that) |
00:59 | ||
smls added simple type graphs to github.com/perl6/doc/issues/116 | 01:00 | ||
AlexDaniel | m: say split(//, "a;b;c").perl; | 01:01 | |
camelia | rakudo-moar a32c14: OUTPUT«5===SORRY!5=== Error while compiling /tmp/jP3UgDZBS5Null regex not allowedat /tmp/jP3UgDZBS5:1------> 3say split(//7⏏5, "a;b;c").perl;» | ||
BenGoldberg | On the one hand, the empty strings at the beginning and ending of the result do seem a bit odd. On the other hand, the documentation for .split says that if the delimiter is a string, it will be searched for literally, and that empty chunks in the result will not be thrown away. | ||
m: say "a;b;c".split(qx//).perl | 01:02 | ||
camelia | rakudo-moar a32c14: OUTPUT«qx, qqx is disallowed in restricted setting in sub restricted at src/RESTRICTED.setting:1 in sub QX at src/RESTRICTED.setting:11 in block <unit> at /tmp/8gYvMdK1vh:1» | ||
BenGoldberg | m: say "a;b;c".split(qr//).perl | ||
camelia | rakudo-moar a32c14: OUTPUT«5===SORRY!5=== Error while compiling /tmp/vAMtG95IEUUnsupported use of qr for regex quoting; in Perl 6 please use rx//at /tmp/vAMtG95IEU:1------> 3say "a;b;c".split(qr7⏏5//).perl» | ||
BenGoldberg | m: say "a;b;c".split(rx//).perl; # stupid fingers. They prefer to type perl5, even when they should know otherwise! ;) | 01:03 | |
camelia | rakudo-moar a32c14: OUTPUT«5===SORRY!5=== Error while compiling /tmp/U14xx6T9CKNull regex not allowedat /tmp/U14xx6T9CK:1------> 3say "a;b;c".split(rx/7⏏5/).perl; # stupid fingers. They prefer » | ||
smls | BenGoldberg: splitting into characters is what .comb is for | ||
BenGoldberg | m: say "a;b;c".split(rx/. ** 0..0/).perl; | 01:04 | |
camelia | rakudo-moar a32c14: OUTPUT«("", "a", ";", "b", ";", "c", "")» | ||
BenGoldberg | smls, This isn't python. There *is* more than one way to do it. | 01:06 | |
01:10
jkva joined
|
|||
ShimmerFairy | For those null regexes, you wanted this, I believe: | 01:13 | |
m: say "a;b;c".split(/<?>/) | |||
camelia | rakudo-moar a32c14: OUTPUT« a ; b ; c » | ||
ShimmerFairy | m: say "a;b;c".split(/<?>/).perl | ||
camelia | rakudo-moar a32c14: OUTPUT«("", "a", ";", "b", ";", "c", "")» | ||
AlexDaniel | same empty strings | 01:14 | |
01:14
jkva left
|
|||
AlexDaniel | hm | 01:14 | |
ShimmerFairy | m: "a;b;c" ~~ m:g/<?>/; say $/».from | 01:15 | |
camelia | rakudo-moar a32c14: OUTPUT«0 1 2 3 4 5» | ||
01:16
smls left
|
|||
ShimmerFairy | <?> (and '' as well) match every string position, so .split causes a split at each of those positions. For positions 0 and 5, that means one side is the empty string | 01:16 | |
(keeping in mind that regex positions are _between_ characters, like a |-style typing cursor) | |||
Juerd | m: say "a;b;c".split(/<after .><before .>/).perl # silly | 01:20 | |
camelia | rakudo-moar a32c14: OUTPUT«("a", ";", "b", ";", "c")» | ||
ShimmerFairy | Juerd: heh, that's shorter than my version :P | ||
AlexDaniel | m: say split(';', 'a;b;c', :all).perl; | ||
camelia | rakudo-moar a32c14: OUTPUT«(("a", ";"), ("b", ";"), "c")» | ||
ShimmerFairy | m: say "a;b;c".split(/<!before ^> <?> <!before $>/).perl | ||
AlexDaniel | list of lists? | ||
camelia | rakudo-moar a32c14: OUTPUT«("a", ";", "b", ";", "c")» | ||
01:21
cognominal left
|
|||
AlexDaniel | doc.perl6.org/routine/split#class_Cool has a different example | 01:21 | |
Juerd | m: say "a;b;c".split(/<?>/).grep({ .length }).perl | ||
camelia | rakudo-moar a32c14: OUTPUT«Method 'length' not found for invocant of class 'Str' in block <unit> at /tmp/dkIiW1euSp:1» | ||
Juerd | m: say "a;b;c".split(/<?>/).grep({ .chars }).perl | 01:22 | |
camelia | rakudo-moar a32c14: OUTPUT«("a", ";", "b", ";", "c")» | ||
Juerd | m: say "a;b;c".split(/<?>/).grep(*.chars).perl | ||
ShimmerFairy | AlexDaniel: not sure if that's intended, but the way it is has a nice effect of giving you some information on what the split information is like | ||
camelia | rakudo-moar a32c14: OUTPUT«("a", ";", "b", ";", "c")» | ||
ShimmerFairy | m: say split(';', ';a;b;c;', :all).perl; | ||
camelia | rakudo-moar a32c14: OUTPUT«(("", ";"), ("a", ";"), ("b", ";"), ("c", ";"), "")» | ||
ShimmerFairy | the "cdr" of each list contains what you split on in front of the "car" of each list, if the last element is the empty string you know the string ended in a split-upon thing, and if the "car" of the first list is the empty string you know the string started in a split-upon thing | 01:23 | |
AlexDaniel | ShimmerFairy: every odd element is a delimiter anyway, isn't it? | ||
ShimmerFairy | AlexDaniel: yes, especially once you flatten the list :) | ||
AlexDaniel | anyway, the example is wrong | 01:24 | |
or the implementation is wrong | |||
ShimmerFairy | that's certain :) . But like all list-related things, there's a weird feeling (at least for me) of waiting for the looming GLR to come in and change how things work. | 01:25 | |
AlexDaniel | uhhhh | ||
ok, then it's time to get some sleep | |||
ShimmerFairy | g'night, AlexDaniel o/ | 01:26 | |
To be clear, there's nothing wrong with fixing either .split or the documentation, but (again, at least for me) the GLR means anything list-related has some extra uncertainty around it for the time being. | |||
AlexDaniel | that's ok, I wrote it down in my notes | 01:27 | |
I'll check it later | |||
01:49
llfourn joined
01:51
pdcawley_ left
01:52
millican joined
01:56
millican left
|
|||
dalek | kudo/jvm-testing: 68623c9 | hoelzro++ | .travis.yml: Test JVM backend on Travis |
01:59 | |
ShimmerFairy | Hm. When a string begins with a mark (category M) character, Perl 6's parser correctly parses that as a double-quote with a diacritic, for example. My question is, should delimiters be matched under :ignoremark (with the marks ignored perhaps then being picked up as being inside the delimited thing), should they be considered a distinct delimiter, or should they be left as they are? | 02:04 | |
m: say q[̈hello[̈ | |||
camelia | rakudo-moar a32c14: OUTPUT«hello» | ||
dalek | kudo/jvm-testing: 7247fe2 | hoelzro++ | .travis.yml: Temporarily remove branch restriction on Travis |
||
02:05
TEttinger joined
|
|||
ShimmerFairy | currently, something like a left bracket with an umlaut is seen as the kind of delimiter you have to repeat. The question is, should [̈hello]̈ work, which would require either :ignoremark or recognizing distinct "marked" delimiters, and if so should [̈̈hello] or [hello]̈ work too (which would only work with :ignoremark)? | 02:05 | |
A related question is if that initial combining umlaut should be taken as part of a string, or not. | 02:06 | ||
m: say "@̈" ~~ /:ignoremark \@/ # important to note that :ignoremark doesn't work generally at the moment | 02:07 | ||
camelia | rakudo-moar a32c14: OUTPUT«Nil» | ||
02:19
travis-ci joined
|
|||
travis-ci | Rakudo build failed. Rob Hoelz 'Temporarily remove branch restriction on Travis' | 02:19 | |
travis-ci.org/rakudo/rakudo/builds/75019582 github.com/rakudo/rakudo/compare/6...47fe26ee11 | |||
02:19
travis-ci left
02:20
davido__ left
02:22
davido__ joined,
aborazmeh joined,
aborazmeh left,
aborazmeh joined,
aborazmeh left
02:23
dayangkun joined
02:25
aborazmeh joined,
aborazmeh left,
aborazmeh joined
|
|||
dalek | kudo/nom: 68623c9 | hoelzro++ | .travis.yml: Test JVM backend on Travis |
02:28 | |
02:33
labster joined
02:37
noganex_ joined
02:39
noganex left
02:41
travis-ci joined
|
|||
travis-ci | Rakudo build failed. Rob Hoelz 'Test JVM backend on Travis' | 02:41 | |
travis-ci.org/rakudo/rakudo/builds/75021291 github.com/rakudo/rakudo/compare/7...623c92d332 | |||
02:41
travis-ci left
02:48
AlexDaniel left
|
|||
[Coke] | ignoremark is for the content, not the delimeter, I thought. | 02:54 | |
ShimmerFairy | [Coke]: well, I was talking for the Perl 6 parser, should it use ignoremark to match delimiters, or otherwise recognized Ps/Pe/Pi/Pf characters with marks as "marked" version of such, or neither. | 02:57 | |
*recognize | 02:58 | ||
02:58
llfourn left
|
|||
dalek | ast: 9df21c3 | ShimmerFairy++ | fudge: Fix 'eval' fudge to use EVAL() instead of eval() |
03:05 | |
ast: 40ff238 | ShimmerFairy++ | S15-literals/ (2 files): Add tests for Unicode literals This adds two new test files, one for identifiers and one for numbers. The numbers one is fudged for rakudo for now, but the identifiers one already passes for rakudo :) . |
|||
03:09
bin_005_p joined
03:11
jkva joined
03:15
jkva left
|
|||
skids | .tell jnthn gist.github.com/skids/edac2cebdab5c6bd7641 # did not get far -- but hey, actual error messages do help, right? | 03:19 | |
yoleaux | skids: I'll pass your message to jnthn. | ||
[Coke] | I would argue it probably shouldn't match any marks on quoting chars | 03:21 | |
(delims) | |||
03:23
llfourn joined
|
|||
ShimmerFairy | The minimum case would be an error that you started the contents with an M category character (that should definitely be the error if you start a variable name with an M category char, for example), I just wonder if there isn't a nicer solution than giving up so quickly. | 03:24 | |
Since you can start a string with a mark by using \x or \c, at least for strings I don't think it's necessary to consider the mark as the first codepoint of content. | 03:26 | ||
I personally think it'd be neat to be able to use, say, umlauted braces for embedded comments and such, but it's certainly not the only solution :) . | 03:30 | ||
03:31
gfldex left
03:41
bin_005_p left
03:45
millican joined
03:46
laouji left
|
|||
ugexe | while its a good idea to travis test jvm, it probably does not help our image to have a prominent `build failing` badge due because of a secondary VM target | 03:52 | |
i would suggest an allowed failure for JVM, as seen here: github.com/ugexe/zef/blob/master/....yml#L8-L10 | 03:55 | ||
04:05
leont left
04:15
skids left
04:30
davido___ joined
04:32
davido__ left
04:34
BenGoldberg left
04:47
[Sno] left
04:50
xinming_ joined
04:51
laouji joined
04:53
xinming left
|
|||
TimToady | .tell jnthn maybe it's not either/or; perhaps Slip is a role that can be composed with Nil? | 05:01 | |
yoleaux | TimToady: I'll pass your message to jnthn. | ||
05:11
Possum left
05:12
jkva joined
05:16
jkva left
05:26
millican left
05:43
xinming_ left
05:44
xinming joined
05:55
rurban joined
05:58
jkva joined,
diana_olhovik joined
06:07
mr-foobar left
06:10
mr-foobar joined
06:13
Possum joined
06:15
gfldex joined
06:16
jjido joined
06:21
[Sno] joined
|
|||
[Tux] | test 50000 43.501 43.120 | 06:21 | |
test-t 50000 42.463 42.082 | |||
HLL still unfixed | 06:22 | ||
06:32
kurahaupo left
06:35
ecocode joined
06:42
fxer joined
06:43
TimToady left
06:52
TimToady joined
|
|||
Sgeo | m: say "a".index("b") | 06:54 | |
camelia | rakudo-moar a32c14: OUTPUT«Nil» | ||
Sgeo | I'd ask why not redefine truthiness to be definedness, but False is defined and falsey and really, really needs to be both | 06:55 | |
06:56
yeahnoob joined,
RabidGravy joined
|
|||
RabidGravy | marning! | 07:00 | |
Sgeo | hi | ||
I should be asleep | |||
07:01
baest_ joined
07:02
baest left
07:04
fxer left
07:09
fxer joined
07:11
SamuraiJack joined
07:13
aborazmeh left
07:16
mr-foobar left
07:20
fxer left
|
|||
RabidGravy | Boo! it appears the RT#125408 has come back (and the canary test does fail) | 07:22 | |
07:24
zakharyas joined
07:27
jjido left
07:31
fxer joined
07:33
mr-foobar joined
07:36
fxer left
07:41
araujo joined
07:43
mr-foobar left
|
|||
lizmat | smls: re irclog.perlgeek.de/perl6/2015-08-11#i_11036392 | 07:44 | |
it should be noted that part of the "mess" regarding Hash and friends, is caused by the fact that no backend has an implementation of object hashes | 07:45 | ||
the spec assumes all hashes are object hashes, and the ones with Str are a special case of it | 07:46 | ||
in reality, it's the other way around: all hashes have Str for keys, object hashes needed to be bolted on to that | |||
personally, I don't think this is going to be fixable before Christmas | |||
jnthn | lizmat: I don't think that's the "mess" he's refering to, fwiw. That's more an implementation detail. | 07:47 | |
yoleaux | 10 Aug 2015 23:18Z <b2gills> jnthn: Any.join should have an optional or default separator | ||
03:19Z <skids> jnthn: gist.github.com/skids/edac2cebdab5c6bd7641 # did not get far -- but hey, actual error messages do help, right? | |||
05:01Z <TimToady> jnthn: maybe it's not either/or; perhaps Slip is a role that can be composed with Nil? | |||
jnthn | .tell TimToady Slip is just a subclass of List, and it really needs to be that way... I guess Nil could be a role maybe... | ||
yoleaux | jnthn: I'll pass your message to TimToady. | 07:48 | |
jnthn | lizmat: I think it's more the EnumMap and PairMap types | ||
tbh I'd just rename EnumMap to Map | |||
There's nothing enum about it | |||
lizmat | well, as I'm more familiar with QuantHash and anything below it, I agree it's a mess | ||
but it works :-) | |||
jnthn | On the inside, or the outside? | 07:49 | |
ShimmerFairy | Yeah, it's specifically the fact that non-Hash Associative things in core are a bit more mysterious than most core types :) | ||
(to the average user) | |||
lizmat | jnthn: on the inside | ||
jnthn | lizmat: Right, I think smls is talking about on the outside. | ||
lizmat: I'm not too concerned about the insides wrt 6.christmas; insides we're free to fix down the line. :) | |||
lizmat | indeed, that's why I'm not too worried either :-) | 07:50 | |
jnthn | I think the Set/Bag/Mix stuff at least got well thought out at some point | ||
lizmat | yeah, but the implementation does not match the spec wrt to hierarchy | ||
jnthn | But yeah, what is PairMap for is one good question, and why does EnumMap have the word Enum in it and why is an immutable Pair an Enum? :) | ||
It's really confusing because they have nothing to do with the enum keyword. | 07:51 | ||
lizmat | well, I implemented PairMap because it hadn't been done yet and was reatively easy | ||
ShimmerFairy | I think the Set/Bag/MixHash types would do better if 'Hash' were instead a more descriptive name for the fact that it's mutable. (But maybe it already is and it's my fault I'm not familiar enough with the word 'Hash' :P) | ||
lizmat | SetMut BagMut MixMut :-) | 07:52 | |
jnthn | ShimmerFairy: I think the quoting stuff's behavior is consistent with an NFG world view. I don't have any desire to make quote parsing more complex. In an NFG world you basically never see something of mark category unless you specifically write \c[COMBINING CUTE ABOVE] or whatever. | ||
Well, once you know %h is called a Hash (and you know it's mutable) then *Hash is pretty nicely indicative of "it's a Hash with some different semantics". | 07:53 | ||
07:54
rurban_ joined
|
|||
jnthn | Hash is just from the computer science name for the data structure ("hash table") | 07:54 | |
ShimmerFairy | Fair enough on Hash, but approaching it from the angle of "I know what Set/Bag/Mix are, what are these *Hash versions?", it's a bit less obvious :) | ||
jnthn | True, though we can document that, and it's predictable given its a productive suffix. :) | ||
ShimmerFairy | (but I don't doubt that "I know what Hash is, what are these Set/Bag/MixHash things?" is an angle that leads to a more immediate understanding) | 07:55 | |
jnthn: and on NFG, the non-ignoremark idea would mean somehow carrying the Ps/Pe/Pi/Pf info from the base codepoint through to the composed thing, which would be very tricky I imagine. | 07:56 | ||
jnthn | ShimmerFairy: Is there any real reason it can't just stay as it is? | 07:57 | |
ShimmerFairy: I don't see the problem at all. If you use one of a certain set of graphemes that have an opening/closing pair, you get the opener/closer semantics. | |||
ShimmerFairy | jnthn: no, not really. I just thought it'd be neat if it didn't error out, but what not-an-error looks like is admittedly interesting. | ||
jnthn | ShimmerFairy: If you use any other grapheme that's acceptable as a quoting character then you get the identical closer thing. If you put a mark on a [ it's a different grapheme. | 07:58 | |
JimmyZ | so I am not the only one who thinks why EnumMap has Enum :) | ||
ShimmerFairy | Theoretically it would possibly look like /$<open>=(<C/ \" <:Mark>* />) ~ $<open> [stuff]/ to parse a double-quote with funny marks, for example (using those "grapheme exploders" in S15 that are a bit of small extra feature) | 08:01 | |
dalek | kudo/nom: 14939e3 | lizmat++ | src/core/Cool.pm: Handle out-of-bounds pos in index/rindex better Fixes #125784 |
||
ShimmerFairy | jnthn: I at least hope for descriptive "misplaced Mark character" message somewhere in the distant future, for things like my $̈starts-with-umlaut ; (where you accidentally gave perl6 a "dollar sign with umlaut" grapheme) | 08:02 | |
dalek | ast: 128708a | lizmat++ | S32-list/minmax.t: Fix number of tests to run |
08:04 | |
ShimmerFairy wonders if the other Great Compiler Writers ever find themselves with unstaged changes across all three of MVM, nqp, and rakudo, or if she's just bad at git-ing properly :P | 08:07 | ||
08:09
rindolf joined
|
|||
arnsholt | I haven't worked much on Moar, but a bunch of interlocking changes on both NQP and Rakudo, sure | 08:09 | |
dalek | line-Perl5: 85c5641 | (Stefan Seifert)++ | / (4 files): New sugar for v6::inline constructors v6-inline got renamed to v6::inline, because perl does not support import lists with the v6-inline parse hack. You can now use v6::inline constructors => [qw(create)]; to automatically get a constructor called "create" that wraps a method of the same name you inherited and sets everything up, so you get an object of the Perl 6 subclass v6::inline created. For example in a DBIx::Class::Result class, you normally inherit constructors called "new" and "inflate_result". You can write your Result class in Perl 6 by adding: use v6::inline constructors => [qw(new inflate_result)]; method foo() { ... } |
08:11 | |
ast: e29df31 | lizmat++ | S32-str/ (2 files): Add tests for #125784 |
|||
ShimmerFairy | Yeah, I think need to go back, make some branches, and make some incremental commits before the size of the changes get too out of hand :) | 08:12 | |
(It's funny to think "oh, I'll fix this problem!" and within two seconds you trace it down to the virtual machines :P) | 08:13 | ||
RabidGravy | yeah, I find that frequent commits make merging upstream changes less fraught | ||
lizmat | afk& | ||
08:15
bjz joined
|
|||
ShimmerFairy | I think it'll help immensely with the fact that just what I've been doing tonight has really annoyed me in the part where I very frequently switch between three repos, and thus also makes me worry I'll forget what I've done :) | 08:16 | |
jnthn has a tab on his terminal for each, always consistently ordered :) | 08:17 | ||
08:17
g5 joined
|
|||
ShimmerFairy | jnthn: I had to upgrade to two tabs dedicated to P6 work, so I could at least have one on MVM :) (I've got 10 tabs total) | 08:18 | |
08:18
dakkar joined
08:19
travis-ci joined
|
|||
travis-ci | Rakudo build failed. Elizabeth Mattijsen 'Handle out-of-bounds pos in index/rindex better | 08:19 | |
travis-ci.org/rakudo/rakudo/builds/75049615 github.com/rakudo/rakudo/compare/6...939e39d245 | |||
08:19
travis-ci left
08:26
laouji left
08:30
laouji joined
08:46
bjz left
08:51
brrt joined
08:53
espadrine joined
08:56
davido___ left
08:58
davido___ joined
09:01
telex left
09:02
telex joined
09:04
fling left,
jkva left
09:10
fling joined
|
|||
dalek | line-Perl5: 6b39211 | (Stefan Seifert)++ | lib/Inline/Perl5.pm6: Avoid creating circular inheritance hierarchies in v6::extend |
09:14 | |
09:16
fling left
09:17
fling joined
09:20
jkva joined
09:22
fling left,
fling joined
09:28
smls joined
09:30
itz is now known as _itz
09:31
itz joined
|
|||
itz | mornin' | 09:31 | |
smls | hi itz | 09:35 | |
RabidGravy | mornin itz | 09:37 | |
09:49
brrt left
09:54
yeahnoob left
10:00
tinyblak left
10:02
darutoko joined,
tinyblak joined
10:04
|Tux| left
10:07
leont joined
|
|||
dalek | c: f05cce9 | lizmat++ | lib/Type/Supply.pod: Document signal() |
10:08 | |
smls | "is SuperClass", what's that? | 10:09 | |
10:09
jkva left,
tinyblak left,
|Tux| joined
|
|||
smls | in github.com/perl6/doc/blob/master/l...Supply.pod | 10:10 | |
m: say SuperClass | |||
camelia | rakudo-moar a32c14: OUTPUT«5===SORRY!5=== Error while compiling /tmp/V6gzCkBc4MUndeclared name: SuperClass used at line 1» | ||
10:11
jkva joined
|
|||
jnthn | wtf is SuperClass? | 10:11 | |
Like SuperMan, but it runs methods instead of flies? | 10:12 | ||
smls | git blame's moritz | ||
jnthn | :) | 10:13 | |
I suspect it was a copy-pasto | |||
smls | something like that | ||
jnthn | Or a template fill-out failure | ||
I'd just remove it :) | |||
smls | ok | ||
10:13
TimToady left
10:15
jkva left,
TimToady joined
|
|||
dalek | c: 20e6c88 | smls++ | lib/Type/Supply.pod: remove left-over fragment from type page template |
10:15 | |
smls | jnthn: You were right, it's part of the template at github.com/perl6/doc/blob/master/C...IBUTING.md | 10:16 | |
RabidGravy | lizmat, there appears to a few places in the Supply.pod where "elements" is used rather than "events" is that just accidental? | 10:17 | |
smls | I suppose events are the elements of a Supply? | 10:18 | |
Though "events" is clearer | |||
10:19
jkva joined
|
|||
RabidGravy | and used most of the way through the document, it's just the methods lizmat added the other day | 10:19 | |
jnthn | I wonder whether we'll want to call the things you get from working through a Seq "elements" or not. | 10:23 | |
smls | "values" always works | 10:24 | |
jnthn | Yeah :) | ||
For both | |||
10:24
rurban left
|
|||
jnthn | Maybe we can use elements for talking about actual storage slots in a reified data structure, and values for things "on the move" | 10:24 | |
Using values for Seq and Supply kinda emphasizes the duality | |||
10:25
baest_ left,
baest joined
|
|||
ShimmerFairy | jnthn: have you figured out the Seq.perl question yet? My first though is something like "{self.VAR.name}.list.Seq" , depending on if you can convert to a Seq and if you can get the containing variable's name like that :P | 10:25 | |
dalek | c: 0bcc5fb | RabidGravy++ | lib/Type/Supply.pod: change a few 'element' to 'event' |
10:27 | |
jnthn | ShimmerFairy: It's a tricky one. If somebody does @foo.map(*.bar).perl then they might like to see the results... | ||
RabidGravy | I changed most of them | ||
changed one to 'items' as that made more sense in the context | |||
jnthn | ShimmerFairy: We can always self.list.perl ~ '.Seq' maybe.. | 10:28 | |
ShimmerFairy: But then .perl'ing a Seq will deplete the iterator | |||
ShimmerFairy | jnthn: as long as you can construct a Seq from a list, then Seq.perl might be one of the rare .perl methods (and those like it) that does more than simply construct a string, by constructing a string _and_ making itself seem as though it were untouched :) | 10:29 | |
jnthn | ShimmerFairy: So your efforts to debug could give you a problem | ||
Yeah, we'd have to maybe make a clone of the iterator... | |||
smls | .gist can just do .list.gist, right? | ||
jnthn | smls: Yeah | ||
ShimmerFairy | jnthn: oh yeah, duh. The simpler solution would be to clone itself and deplete the clone :P | ||
lizmat | RabidGravy: I asked yesterday already... | 10:31 | |
what to call something generically that has been emitted to a Supply | |||
(please note that some of the verbage predates the use of "emit()") | 10:32 | ||
RabidGravy | :) | ||
10:32
spider-mario joined
|
|||
jnthn | lizmat: Yeah. Today I really do wonder if we should just talk about values, flowing through the chain of supplies. | 10:32 | |
lizmat: Or being pushed through, as opposed to a Seq where they're being pulled through :) | |||
10:33
jkva left
|
|||
lizmat | "values" works for me | 10:33 | |
jnthn | Maybe it's 'cus I did the guts of both, but post-GLR the duality between Seq and Supply is a lot more obvious. | 10:34 | |
10:34
Begi joined
|
|||
Begi | In Perl5, we have system('command'); What can I use with Perl 6 ? | 10:35 | |
ShimmerFairy | Maybe it's because I've been around Perl 6 too long, but I'm really trying to come up with a cute name for what Seqs return :P (not familiar enough with Supplys to try the same) | ||
jnthn | ShimmerFairy: When you iterate them? Just values... :) | 10:36 | |
RabidGravy | it's conceptually a bit convoluted with Supply because emit can be thought of as creating an event and the value is passed to all the "event handlers" | ||
tadzik | Begi: run() or shell() | 10:37 | |
smls | Begi: run('prog', 'arg1', 'arg2') | ||
see doc.perl6.org/type/Proc | |||
jnthn | RabidGravy: Do you think it's conceptually a bit convoluted that .map returns a value that is passed to the thing that wanted a value? :) | ||
Begi | Ok, thanks ! | ||
tadzik | Begi: or doc.perl6.org/routine/shell :) | ||
jnthn | RabidGravy: In both cases you're got code producing a value and some infrastructure making it end up in the right place... | 10:38 | |
RabidGravy | well yes but that's a generalisation | 10:40 | |
:) | |||
smls | jnthn: Is it just me, or does Channel start to look more like a low-level/special-purpose type now that Supply is really comming into its own? | 10:41 | |
10:42
azawawi joined
|
|||
azawawi | hi | 10:42 | |
jnthn | smls: Channels are more about moving data between threads, whereas supplies are more about coordinating flows of data that may originate on many threads, but want actor semantics over the pipeline | 10:43 | |
azawawi | any idea how to generate POD/markdown documentation on github repos? i.e. to provide inline documentation for module Foo | 10:44 | |
10:44
RabidGravy left
|
|||
ShimmerFairy | You can use Pod6 to document stuff, of course, but I don't think github does anything with it (I'm not sure if it does anything with POD5-formatted stuff, even) | 10:45 | |
azawawi | sort of like metacpan (e.g. metacpan.org/pod/distribution/Plac...t/plackup) but on github | ||
i think they now support P5 POD github.com/github/markup/blob/mast...md#markups | 10:46 | ||
ShimmerFairy | No, I'm sure github offers nothing like that, aside from however you format your README files :) | ||
(and other files purely in supported formatting styles, that is) | 10:48 | ||
leont | Basically, they seem willing to support any format if you write the implementation | ||
10:49
bjz joined
|
|||
ShimmerFairy | Pod6 would require either making github run Perl 6 (which might take some time yet), or for some brave soul to attempt writing a Pod6 formatter in some other language :) | 10:49 | |
lizmat | hmmm... maybe we should change Supply.batch(:elems) to Supply.batch(:nrofvalues) ? | 10:50 | |
leont | :by ? | 10:51 | |
10:51
Begi1 joined
10:52
Begi left,
jkva joined
|
|||
leont | nrofvalues seems to big and isn't really a word | 10:52 | |
lizmat | eh, no, that's already used with sort and friends | ||
yeah, I know, that was just to get the brain cells of everybody reading going :-) | |||
ShimmerFairy | lizmat: my first inclination would be :valno , but perhaps not in something beyond my personal projects :) | ||
lizmat | I mean: :values is ambiguous as well | ||
10:52
rurban joined
|
|||
jnthn | Well, given batch builds a list of things to emit that has that number of elems, elems is kinda fine. | 10:53 | |
ShimmerFairy | .oO(obviously it should be Supply.batch(:#values) ) |
||
jnthn | Provided you appreciate it's talking about the number of elems you'll have in the resulting list. :) | ||
lizmat | yes, it is | ||
jnthn | .batch(:5elems) # I want batches of 5 elements :) | 10:54 | |
10:54
jkva_ joined
|
|||
lizmat | that's how it works :-) | 10:54 | |
jnthn | Right, I'm saying I think it works OK :) | ||
ShimmerFairy | heh, totally forgot that :5values (for example) would suddenly make it not ambiguous :) | 10:55 | |
10:56
jkva left
10:58
tinyblak joined
|
|||
smls | Does anyone know what the story behind the 'EnumMap' and 'Enum' class names is? (Seeing how they have nothing to do with the 'enum' keyword, right?) | 11:01 | |
azawawi | ShimmerFairy: found it :) github.com/github/markup/blob/mast...ups.rb#L46 | 11:03 | |
11:03
TEttinger left
|
|||
azawawi | ShimmerFairy: we could add p6 support to github easily :) | 11:03 | |
ShimmerFairy: s/p6/p6 pod/ | |||
ShimmerFairy | Not so simple, because P6 unlike P5 is not on every UNIX server on the planet (yet) :) | 11:04 | |
azawawi | damn | ||
azawawi looks up rakudo package @ debian | 11:05 | ||
ShimmerFairy | so you'd either have to convince the people at github to install rakudo (so they can use Pod::To::HTML for P6 Pod), or write a Pod6 converter in some other language. | ||
(And honestly, P6's Pod::To::HTML needs some cleanup before I'd be willing to recommend a big site like github to use it) | |||
lizmat | m: say (enum <a b c>).WHAT # smls | ||
camelia | rakudo-moar a32c14: OUTPUT«(EnumMap)» | ||
11:06
Begi1 left
11:07
bjz left
|
|||
azawawi | ShimmerFairy: true | 11:08 | |
smls | lizmat: Interesting. So it's just *named* enums that that loose all public connection to that type? | ||
m: enum A <a b c>; say A ~~ EnumMap; A.^mro; | |||
camelia | rakudo-moar a32c14: OUTPUT«False» | ||
smls | m: enum A <a b c>; say A ~~ EnumMap; say A.^mro; | ||
camelia | rakudo-moar a32c14: OUTPUT«False(A) (Int) (Cool) (Any) (Mu)» | ||
ShimmerFairy | The two main issues I have with Pod::To::HTML, to be clear, are 1) that embedded stylesheet (I don't think ::HTML should be embedding a default stylesheet, esp. with no way to turn it off), and 2) the handling of C<=item>s | 11:09 | |
azawawi wonders if Pod::To::HTML can generate old p5 pod | |||
Pod6::To::Pod | 11:10 | ||
ShimmerFairy | Nope, if you want that you'd be looking for Pod::To::POD5 :) | ||
smls | m: enum A <a b c>; say A.enums.WHAT | ||
camelia | rakudo-moar a32c14: OUTPUT«(Hash)» | ||
azawawi | ShimmerFairy: hmmm use Pod::To::Markdown to generate github markdown files :) | 11:11 | |
ShimmerFairy | I'd rather not support the use of Markdown when we should be using the superior Pod6, though :P | 11:12 | |
azawawi | ShimmerFairy: frankly i dont see why (for simple cases) we need Pod6 instead of Markdown :) | ||
ShimmerFairy: you're typing less with markdown | |||
ShimmerFairy | In reality I don't mind if you use markdown for stuff, I just find a bit disappointing that more Perl 6 stuff (especially the _core_ Perl 6 stuff) isn't using Pod6 :( | 11:13 | |
*find it | |||
dalek | c: 214baa0 | lizmat++ | lib/Type/Supply.pod: Override previous changes |
11:15 | |
azawawi | ShimmerFairy: take this example github.com/sergot/http-useragent#infodoc. sergot++ is doing an excellent job to make his modules documented. Note the @L<line-number> links which can change when edits the files | 11:16 | |
ShimmerFairy: s/edits/one edits/ | |||
ShimmerFairy | I don't see why you couldn't link to line numbers like that with Pod L<> codes | 11:18 | |
11:19
dayangkun left
|
|||
dalek | ast: 3f1a7a0 | lizmat++ | S17-supply/c (2 files): Fix typos |
11:21 | |
azawawi | ShimmerFairy: he was trying to link to actually pod documentation which if it was a seperate .pod file then github would render it into a nice readable HTML document. | ||
ShimmerFairy: .pod or .markdown that is | |||
ShimmerFairy: s/to actually/to/ # sleepy a bit :) | 11:23 | ||
so what's the best practise inline pod, pod at the end of a module or pod seperated from code? | 11:24 | ||
ShimmerFairy | I think after improvements to Pod::To::HTML and at best the September release, we might be able to convince github to be an early player in Perl 6's domination of computers everywhere, just like Perl 5 :) | ||
azawawi: I think the best procedure would be to put description with #|{} or #={} (forget which does which), and have more detailed info in a separate section. | 11:25 | ||
azawawi | ShimmerFairy: do you have an actual example? | ||
ShimmerFairy | If github doesn't want to a doxygen-like thing of processing code for documentation, that's not your fault :) | ||
azawawi: not off-hand, no | 11:26 | ||
I definitely feel like Pod6 has suffered from a lack of widespread usage :/ | |||
azawawi | ShimmerFairy: that's the thing that worries you in Pod::To::HTML github.com/perl6/Pod-To-HTML/blob/...ML.pm#L106 ? | ||
simple to use and remember always works :) | 11:27 | ||
ShimmerFairy | azawawi: yes, but that's simple to fix (someone just has to do it :P). The bigger issue is the fact that =item handling is broken (look at the source of any converted HTML with lists, you see the items wrapped in two <li><li>...</li></li> codes, IIRC) | ||
smls | lizmat: Do you also know why EnumMap treats it's entries as Pair's, rather than Enum's as its name suggests? Whereas the Set, Bag and Mix *do* use Enum? | 11:28 | |
ShimmerFairy | And you want to use =item2 ? Forget about that making sense in the rendered HTML :P | ||
lizmat | not sure, but Enums in Set/Bag/Mix are used because they're immutable | 11:29 | |
azawawi | ShimmerFairy: just looking at the code, we should have used a Template::Mojo or Template::Mustache and provided the API user a way to define his own templates, right? | ||
ShimmerFairy | ? I don't think templates factor into this. | ||
smls | lizmat: Couldn't one also make an immutable Pair by binding its .value to a non-container? | 11:30 | |
After all, Pair is already immutable in the sense that EnumMap and Parcel are immutable - you can not add or remove keys. | |||
azawawi | ShimmerFairy: if you're converting X into Y, Generator classes/templates make it easier a bit to override some behavior | 11:31 | |
smls | It's just that Pair itemizes its value by default | ||
azawawi | ShimmerFairy: please take a look at this ugly hack github.com/github/markup/blob/mast...ups.rb#L47 to see what i mean | ||
ShimmerFairy | Sure, but for Pod it's all about the Pod::To modules, and it's up to them to provide various module-specific options | ||
lizmat | smls: the specifics escape me now, but it used to be possible to change an immutable Set/Bag/Mix when .pairs did not return Enums | 11:33 | |
smls | lizmat: Alternatively, would anything suffer if Pair behaved like enum does now (no forced itemization), and Hash.pairs just happens to return Pair's with an item container as value? | ||
lizmat | not sure whether you can somehow do that with EnumMap now as well | ||
11:33
firefish5000 left
|
|||
lizmat | smls: I have no idea | 11:33 | |
11:34
tinyblak left
|
|||
itz | what's the status of Native Shaped Arrays? | 11:37 | |
lizmat | not yet in shape | ||
but pretty native | 11:38 | ||
11:39
rurban left
|
|||
itz | ha! nice summary! quite stealable for some slides | 11:39 | |
11:44
bjz joined
|
|||
dalek | c: 92f44b4 | lizmat++ | lib/Type/Supply.pod: Another batch of Supply methods being documented |
11:54 | |
11:58
azawawi left
|
|||
jnthn | itz: I postponed the shaped stuff at Perl 6 level to post-GLR | 11:59 | |
itz: However, the MoarVM and JVM backends now have support for compact storage of shaped native arrays | 12:00 | ||
itz: So the guts are prepared | |||
itz | ok thanks | ||
jnthn | But then I had to switch track and worry about the GLR | 12:01 | |
nine | I guess all in all GLR >> NSA | 12:02 | |
jnthn | Well, yeah, I kinda expected the GLR woulda been done by the time I reached shaped arrays | 12:03 | |
12:05
brrt joined
|
|||
jnthn | At some point FROGGS was like "jnthn can't do all 3 of NFG, GLR, and NSA". Apparently he can. :P | 12:05 | |
itz | I still parse GLR as looking like a railway name so switching tracks looks appropriate | ||
jnthn | :D | ||
Great List Railway | |||
arnsholt | Speaking of NFG: For implementing it on JVM, I assume one necessary part of it is replacing most occurences of java.lang.String in NQP/JVM with our own NFGString (or whatever it ends up being called) and a bunch of NFG-related ops. Are there more major parts involved? | 12:08 | |
jnthn | arnsholt: Also implementing the NFG algorithm, but that's mostly just porting | 12:09 | |
arnsholt: Question is if we have enough of the UCD available to us | |||
arnsholt: Certainly we lag behind on JVM in various areas of Unicode support 'cus we don't have all the info | |||
arnsholt: So it's worth asking if we want to ditch the JVM's existing normalization support and so on and just implement the whole stack like on MoarVM. | |||
arnsholt | Yeah, that makes sense | 12:10 | |
jnthn | arnsholt: The lock-free-readable synthetic resolution Trie should port easily. | ||
...wow, that was a lot of buzzwords :P | |||
lizmat | afk until much later today& | 12:12 | |
brrt | see you | 12:13 | |
12:15
leont left
|
|||
ShimmerFairy | jnthn: where does Moar lag behind JVM on Unicode support? (At first glance I'd guess anything to do with the UniHan database) | 12:19 | |
jnthn | ShimmerFairy: Nowhere that the Perl 6 spectest suite exercises :D | 12:21 | |
ShimmerFairy: I dunno if they get the SpecialCasing.txt stuff right on the JVM. | |||
arnsholt makes an NQP issue for NFG on JVM | 12:22 | ||
jnthn | ShimmerFairy: If so, JVM would be ahead of Moar there. | ||
ShimmerFairy | ah yeah, I saw the XXXs in ucd2c.pl, those are other obvious possible areas :) | ||
jnthn | Aye | ||
But I think we provide much broader access to the UCD on Moar. | |||
ShimmerFairy | jnthn: It just surprised me that you said the JVM was ahead in spots; I was kinda under the impression that Moar was one of the more Unicode-supporting VMs out there :) | 12:23 | |
12:24
leont joined
|
|||
ShimmerFairy | jnthn: that's true. As a small example, the code I've added to Moar locally (to handle unicode numerals, if you're interested) would be slightly nicer if UPV_Nd wasn't a 'static' variable :) | 12:24 | |
jnthn | ShimmerFairy: No, I meant JVM is what's lagging behind :) | 12:25 | |
Though I see now I was very confusing in how I wrote it. | |||
ShimmerFairy | jnthn: ah, I thought you were referring to The JVM®, not the nqp implementation on it :) | 12:26 | |
jnthn | ShimmerFairy: To be clear: there's a bunch of Unicode tests in spectest that we pass on Moar, but not on JVM. | ||
And I don't just mean NFG ones. | |||
ShimmerFairy | jnthn: basically I parsed "we lag behind on JVM" as "MVM lags behind compared to JVM" instead of "our nqp implementation is lacking on JVM" | 12:27 | |
leont | JVM's idea of Unicode is a bit disappointing (surrogatesx85) | 12:28 | |
jnthn | ShimmerFairy: Yeah, I don't think I coulda worded it more ambiguously if I'd tried. Sorry. | ||
ShimmerFairy | jnthn: I'd be interested in trying to add NFG support to nqp-j, but I'm scared there's a reason why even you hadn't got it working on there :) | ||
DrForr | JVM hamstrung itself when it decided that Unicode codepoints fit in 16 bits. | 12:29 | |
jnthn | ShimmerFairy: Oh, the reason isn't technical, but project management. | ||
ShimmerFairy | No worries about the parsing issue, if only English were one-pass parsed... :P | ||
jnthn | ShimmerFairy: It's not critical path for 6.christmas. | ||
ShimmerFairy: I don't think it'd be too awful to get it working on JVM, just a lot of grunt work. | 12:30 | ||
ShimmerFairy | DrForr: _Unicode_ hamstrung itself when it give UTF-16 (or was it UCS-2?) surrogate code points, instead of the extensible encoding system UTF-8 gives :) | ||
leont | JSON has similar issues due to Javascript inheriting the "let's expose the 16-bit implementation" because \u only accepts 4 hexadecimals, so you have to encode the individual surrogate pairs of a higher plane character | ||
ShimmerFairy | .oO(The Fight for U+110000!) |
||
jnthn | MoarVM was prepared to eventually do NFG from the start, so it wasn't actually a pain to integrate it when the time came. | 12:31 | |
leont | ShimmerFairy: it doesn't help that the surrogates aren't at the end of the range, so UTF-16 is the only major encoding where character point sort isn't equal to binary-value sort | ||
jnthn | (The VM already had separate "I want graphs" and "I want codes" iterators for over a year before the NFG work started) | ||
ShimmerFairy | leont: I recall when I set up my local mediawiki thing and got to the database part, I specifically chose the option that didn't limit me to a pre-surrogates idea of Unicode :P | 12:32 | |
m: say "Perl 6.\c[CHRISTMAS TREE]" | |||
camelia | rakudo-moar a32c14: OUTPUT«Perl 6.🎄» | ||
ShimmerFairy | jnthn: I'll see how familiar I can get with handling Unicode implementations, and if things go well I might be able to try NFG on nqp-j. jnthn++ for getting the hard work (NFG at all) done, but I'd still like to help how I can with the other Unicode-related stuff :) | 12:35 | |
12:36
rurban_ left
|
|||
jnthn | ++ShimmerFairy | 12:38 | |
12:38
cognominal joined
|
|||
ShimmerFairy | esp. the non-Str string types, they seem to be lacking at the moment. (The Buf-like nature they display as when you 'say' them was unexpected, but I think it's appropriate ☺) | 12:39 | |
12:42
leont left
|
|||
jnthn | Well, if you actually want to write the contents to an IO handle you .write($the-buf) | 12:42 | |
12:44
cognominal_ joined
12:45
cognominal left
|
|||
smls | m: say Hash.HOW | 12:45 | |
camelia | rakudo-moar a32c14: OUTPUT«Method 'gist' not found for invocant of class 'Perl6::Metamodel::ClassHOW+{<anon>}' in block <unit> at /tmp/xWOD9rjVJ2:1» | ||
smls | ^^ is the +{<anon>} what makes typed Hashes work even though it's not a ParametricRoleGroupHOW ? | 12:46 | |
ShimmerFairy | As I recall Array and Hash implement their own ^parameterize method | 12:47 | |
jnthn | smls: Yeah, see the method ShimmerFairy just referred to | 12:48 | |
12:49
ChoHag joined
|
|||
smls | Why doesn't ClassHOW implement that method so custom collection types can use it? | 12:52 | |
12:53
cibs_ joined
|
|||
jnthn | smls: Why can't they today? | 12:53 | |
ShimmerFairy | I've also wondered why classes can't be parameterized (without implementing a metamodel method), but I also wonder if there's an interest in leaving that to just roles. | 12:54 | |
jnthn | smls: The parameterize method in Array doesn't contain any nqp::ops. It's normal Perl 6 code. | ||
smls | ok | 12:55 | |
jnthn | ShimmerFairy: Roles and classes are rather radically different in how they're compiled. | ||
ShimmerFairy | I would imagine :) | 12:56 | |
jnthn | A role is a template that you derive concrete things from. | ||
12:56
skids joined
|
|||
jnthn | That's why you can't augment a role. | 12:56 | |
12:56
jkva_ left
|
|||
ShimmerFairy | Ah, so parameterization is more natural to roles, because they're by design abstract thingies. | 12:56 | |
jnthn | Yeah, parameterization and augmentation are rather incompatible. | 12:57 | |
12:57
cibs left
|
|||
jnthn | So basically, anybody who says classes not being parametric is arbitrary just hasn't thought hard enough about things. :P | 12:59 | |
smls | m: class A does Buf[uint8] { }; class B is A; | ||
camelia | rakudo-moar a32c14: OUTPUT«===SORRY!===P6opaque: missing attribute protocol in compose» | ||
smls | ^^ is this error due to something specific that Buf does, or is that not allowed in general? | ||
ShimmerFairy | jnthn: I didn't think it was arbitrary, just that the reason was unknown to me :) | ||
smls | i.e. composing a parametric role into a class | ||
jnthn | m: class A does Buf[uint8] { }; say 'ok' | 13:00 | |
camelia | rakudo-moar a32c14: OUTPUT«===SORRY!===P6opaque: missing attribute protocol in compose» | ||
13:00
pecastro left
|
|||
jnthn | m: class A does Buf[uint8] is repr('VMArray') { }; say 'ok' | 13:00 | |
camelia | rakudo-moar a32c14: OUTPUT«ok» | ||
smls | ah | 13:01 | |
thanks | |||
jnthn | Buf really wants a low-level array type | ||
It's specific to Blob/Buf | |||
13:01
cibs joined,
jkva joined
|
|||
smls | jnthn: When you say "parameterization and augmentation are incompatible", is that just the run-time augmentation done with `augment`, or also the way classes are assembled at compile-time? | 13:04 | |
13:05
cibs_ left
|
|||
jnthn | smls: augment actually runs at compile time, but it may be a compile time other than that of the original compilation unit declaring the class. | 13:06 | |
smls: The point is that when you concretize a role, that involves making copies of a bunch of things. | |||
(Which are then "filled in" in various ways) | 13:08 | ||
smls | ok | 13:11 | |
13:12
rmgk_ joined,
rmgk is now known as Guest77074,
Guest77074 left,
rmgk_ is now known as rmgk
|
|||
smls | m: say Hash ~~ Cool; say Pair ~~ Cool; | 13:18 | |
camelia | rakudo-moar a32c14: OUTPUT«TrueFalse» | ||
smls | ^^ Anyone know the reason behind this? | ||
13:25
RabidGravy joined
13:26
tinyblak joined
13:32
muraiki joined
|
|||
RabidGravy | boom! | 13:38 | |
13:43
khw joined
14:04
brrt left
14:07
laouji left
|
|||
tony-o | m: say Pair.^mro | 14:08 | |
camelia | rakudo-moar a32c14: OUTPUT«(Pair) (Enum) (Any) (Mu)» | ||
tony-o | m: say Hash.^mro | ||
camelia | rakudo-moar a32c14: OUTPUT«(Hash) (EnumMap) (Iterable) (Cool) (Any) (Mu)» | ||
tony-o | m: say Iterable.^mro | 14:09 | |
camelia | rakudo-moar a32c14: OUTPUT«(Iterable) (Any) (Mu)» | ||
tony-o | smls: because Pair isn't an EnumMap | ||
or Cool | 14:10 | ||
smls | I meant, the conceptual reason behind why Hash is Cool but Pair isn't. | ||
In particular, why Hash is Cool. | |||
jnthn | Cool is really a strongly typed way of achieving weak typing. | 14:12 | |
smls | And I see the benefit of that when it comes to strings + number. | ||
jnthn | It gets you operations that you can sensibly do provided you can coerce to a number and a string. | ||
nine | That's so cool | ||
jnthn | This is in part a hangover from Perl 5 doing so (and the fact that is convenient) | ||
14:12
Zoffix left
|
|||
smls | m: say Cool.^methods.sort(*.name) | 14:13 | |
camelia | rakudo-moar a32c14: OUTPUT«EVAL IO Int Num Rat Real UInt abs acos acosec acosech acosh acotan acotanh asec asech asin asinh atan atan2 atanh ceiling chars chomp chop chr chrs cis codes comb conj cos cosec cosech cosh cotan cotanh ends-with exp flip floor fmt index indices lc lines l…» | ||
jnthn | A possible reason Pair doesn't get to be Cool might be there was no Pair in Perl 5 | ||
smls | I don't think I'd want to call any of those on a Hash | ||
14:13
pecastro joined
14:14
tinyblak left
14:16
tinyblak joined
|
|||
smls | jnthn: Well, you can't really call most of those routines on a hash in Perl 5 either, due to aggressive auto-flattening. | 14:16 | |
Granted, you *can* use arithmetic ops on a hash in Perl 5 to treat it as its number of elements | 14:17 | ||
But with prefix:<+> making that very easy already in Perl 6, that seems like a weak justification to keep it in Cool (while other things that also have an .elemes, such as Set, aren't). | 14:23 | ||
14:23
brrt joined
14:26
rindolf left
14:31
brrt left
|
|||
tadzik | wow, only 4 open PRs | 14:33 | |
has everyone cancelled thirs? :o | |||
14:34
domidumont joined
|
|||
RabidGravy | they get superceded, re-done. things get fixed :) | 14:35 | |
tadzik | so: why does testing stuff require Panda::DepTracker? | 14:36 | |
RabidGravy | it doesn't, but making the META.info via Panda::Bundler.bundle does | 14:38 | |
tadzik | right, I'm wondering why Panda::Tester needed changing | 14:40 | |
hehe: github.com/tadzik/Typed-Subroutines/issues/4 | |||
hoelzro | good morning, #perl6! | 14:41 | |
tadzik | good morning hoelzro! | 14:42 | |
[Coke] | hoelzro: there was chat in backlog about perl6 syntax highlighting on github that you can probably weigh in on . | ||
hoelzro | good morning tadzik, [Coke]! | 14:43 | |
thanks for the backlog tip | |||
hoelzro looks | |||
14:43
domidumont left
|
|||
itz | wasn't that about p6doc syntax parsing? github does perl6 syntax highlighting | 14:43 | |
RabidGravy | because, previously Panda::Bundler used to set $*EXECUTABLE to add the -MPanda::DepTracker, this don't work with Proc::Async, Pamda::Bundler collects the loaded ,modules for build, test and by extension run | 14:44 | |
tadzik | aha, I see | 14:46 | |
RabidGravy | passing the optional @deps leaves the door open for any future similar things | 14:48 | |
tadzik | I wonder if I wouldn't rather have something like $*EXECUTABLE_FLAGS that each Panda::SubTask-thingy has to remember to respect, but I won't hold your PR any longer :) It fixes things, that's the most important thing | ||
RabidGravy | :) | ||
itz wonders if 'Gravy is going to the London.pm Tech Meet on Thu what with b33r and perl 6 being there | 14:53 | ||
RabidGravy | tadzik++ # cheers matey | 14:54 | |
hoelzro | ugexe: nice tip about allowing failures! how does that change the interaction with Travis? you still get a notification, but the build shows up as passing? | 14:56 | |
tadzik | hrm, anyone who'd rather not have META.list sorted by username? | 14:58 | |
tony-o | i'd rather have it by module name | ||
tadzik | ah, then I can't do it with sort(1) though :( | ||
dalek | osystem: 3e677ef | tadzik++ | META.list: Transfer the ownership of File::HomeDir to azawawi++ |
15:01 | |
15:03
jkva_ joined
15:05
jkva left
|
|||
hoelzro | [Coke]: were you talking about irclog.perlgeek.de/perl6/2015-08-11#i_11037871 ? | 15:05 | |
RabidGravy | itz, I'd hate to break my duck having not been to a London.pm tech meeting ever and all ;-) | 15:06 | |
[Coke] | I think so. | ||
hoelzro | shoot, azawawi is no longer here =/ | ||
itz | RabidGravy: I could ecosystem squat perl6-Acme-XAP :P | 15:08 | |
15:08
virtualsue joined
|
|||
smls | In case anyone else is interested in the "general-purpose associative Perl 6 types" situation, I've made a chart giving an overview of the status quo: i.imgur.com/aUPdhVk.png | 15:10 | |
I showed Iterable as a role rather than a class (because the GLR changes that), but otherwise it should match what current Rakudo does. (If not, please correct me.) | 15:11 | ||
15:12
abaugher joined
|
|||
nine | Wow that's a nice chart! And it shows there to be no system behind this. At least none that I can see. | 15:13 | |
RabidGravy | itz, feel free :) You may have to write some workflow/state machine malarkey to get it to work though ;-) | ||
(which is on my todo list but fairly low down) | 15:15 | ||
tony-o | smls++ | 15:21 | |
15:24
brrt joined
15:27
diana_olhovik left,
g5 left
15:34
zakharyas left
|
|||
smls | m: my $x = 5..10; $x.bounds[1] = 8; dd $x | 15:48 | |
camelia | rakudo-moar a32c14: OUTPUT«$x = 5..8» | ||
smls | ^^ Isn't Range supposed to be an immutable value type? | ||
15:50
rurban_ joined
|
|||
smls | m: my $r = 5..10; my $s = set $(5..10), $r; $r.bounds[1] = 8; dd $s | 15:50 | |
camelia | rakudo-moar a32c14: OUTPUT«$s = set(5..8)» | ||
smls | Looks like a bug. | ||
jnthn | smls: Yeah, looks like one to me too | 15:51 | |
15:51
rurban joined
15:58
ecocode left
16:16
brrt left
16:17
jkva_ left
16:19
xinming left
16:20
xinming joined
16:46
mr-foobar joined
16:48
jkva joined
16:51
telex left
16:52
telex joined
16:53
fxer joined
16:55
itz left
17:16
diana_olhovik joined
17:19
jkva left
17:30
dakkar left
17:37
rindolf joined
17:44
SamuraiJack left
|
|||
colomon | m: my $r = 5..10; my $s = set $(5..10), $r; say $s.perl | 17:48 | |
camelia | rakudo-moar a32c14: OUTPUT«set(5..10)» | ||
smls | m: my $r = 5..10; say $r === 5..10; # this is how Set checks identity | 17:51 | |
camelia | rakudo-moar a32c14: OUTPUT«True» | ||
smls | I submitted it as RT #125791 earlier, btw | 17:52 | |
17:59
llfourn left
18:02
jkva joined
18:04
jjido joined
18:07
tinyblak left
18:41
espadrine left
|
|||
dalek | c: 3d461f4 | (Steve Mynott)++ | lib/Type/ (3 files): fix minor typos |
18:46 | |
18:52
domidumont joined
|
|||
dalek | c: 73ba4fd | (Steve Mynott)++ | lib/Type/IO/Socket (3 files): change various Socket .send to .print |
18:54 | |
19:00
khw left,
khw joined
19:03
raiph left
19:07
colomon left,
colomon joined,
virtualsue left
19:18
raiph joined
19:23
yqt joined
19:27
ChoHag left
19:35
nowan left
19:38
nowan joined
19:54
jkva left
19:56
llfourn joined
|
|||
dalek | kudo/nom: 7814349 | lizmat++ | src/core/Range.pm: Make sure Range.bounds is ro, spotted by smls++ Fixes #125791 |
19:58 | |
20:00
llfourn left
20:01
[Sno] left,
domidumont left
|
|||
dalek | ast: d649801 | lizmat++ | S02-types/range.t: Add tests for #125791 |
20:03 | |
20:10
yqt left
20:12
bin_005 joined,
travis-ci joined
|
|||
travis-ci | Rakudo build failed. Elizabeth Mattijsen 'Make sure Range.bounds is ro, spotted by smls++ | 20:12 | |
travis-ci.org/rakudo/rakudo/builds/75151942 github.com/rakudo/rakudo/compare/1...143492b868 | |||
20:12
travis-ci left
|
|||
lizmat | is this going to happen for every commit now, until we fix the JVM build? | 20:13 | |
RabidGravy | or change the travis.yml to shut up about that build | 20:22 | |
smls | m: $h = EnumMap.new("a" => 5, "b" => 10); $h<b>++; say $h | 20:23 | |
camelia | rakudo-moar a32c14: OUTPUT«5===SORRY!5=== Error while compiling /tmp/KE4SAN8HJ3Variable '$h' is not declaredat /tmp/KE4SAN8HJ3:1------> 3<BOL>7⏏5$h = EnumMap.new("a" => 5, "b" => 10); $» | ||
smls | m: my $h = EnumMap.new("a" => 5, "b" => 10); $h<b>++; say $h | ||
camelia | rakudo-moar a32c14: OUTPUT«EnumMap.new(:a(5), :b(11))» | ||
smls | my $h = PairMap.new("a" => 5, "b" => 10); $h<b>++; say $h | ||
m: my $h = PairMap.new("a" => 5, "b" => 10); $h<b>++; say $h | |||
camelia | rakudo-moar a32c14: OUTPUT«Cannot assign to a readonly variable or a value in block <unit> at /tmp/J5NofPeBoI:1» | ||
smls | So itemizing behavior of PairMap and EnumMap is *reversed* compared to what the design docs and p6doc claim? | 20:24 | |
smls will update the chart | 20:25 | ||
that makes the inheritance chain even weirder though. | 20:26 | ||
ugexe | lizmat: github.com/rakudo/rakudo/pull/489 | ||
20:26
breinbaas joined
|
|||
dalek | kudo/nom: fcf27ae | ugexe++ | .travis.yml: allow failures on JVM |
20:27 | |
kudo/nom: c06f4bd | lizmat++ | .travis.yml: Merge pull request #489 from ugexe/patch-15 allow failures on JVM |
|||
lizmat | ugexe++ | ||
smls++ # exposing spaghetti | |||
TimToady | smls: the original intent was that enums be immutable and pairs not | 20:28 | |
yoleaux | 07:47Z <jnthn> TimToady: Slip is just a subclass of List, and it really needs to be that way... I guess Nil could be a role maybe... | ||
TimToady | so if the implementation has them backwards, let's please fix the implementation, not the docs | 20:30 | |
smls | What if both docs and implementation are backwards in their own way? :P | ||
dalek | ecs: b02fdfa | (Steve Mynott)++ | S (2 files): fix minor typos |
20:32 | |
lizmat | m: (a => 42).WHAT.say # should this be an Enum then ? | ||
camelia | rakudo-moar a32c14: OUTPUT«(Pair)» | ||
20:32
rurban_ left
|
|||
TimToady | no | 20:33 | |
m: (a => my $x).WHAT.say | |||
camelia | rakudo-moar a32c14: OUTPUT«(Pair)» | ||
skids | ISTR EnumMap was moved for a quick fix allowing it to be initialized, with the (known to be wrong) side-effect of rw access, but then that never got followed up on maybe? | ||
TimToady | note that pairs can be bound to rw parameters | ||
20:33
darutoko left
|
|||
TimToady | and enums are meant to represent constants | 20:33 | |
lizmat | a => 42 looks pretty constant to me | 20:34 | |
TimToady | it contains a constant, sure | ||
but pairs are supposed to be more like Lisp cons cells | |||
smls | Couldn't an immutable Pair (in the sense that Parcel, and post-GLR List, is immutable) fuilfil both tasks? | ||
20:35
rindolf left
|
|||
TimToady | both which tasks? you certainly can't bind something immutable to a rw parameter and then expect to write to it | 20:35 | |
though one could argue it's immutable like a list, but can hold containers, I suppose | 20:36 | ||
smls | be an immutable constant (hat is safe to use as Set key, for example), but still allow Hash.pairs and similar to be an rw interface | ||
m: my $s = 5; my $l = (4, $s, 6); $s++; say $l | |||
camelia | rakudo-moar a32c14: OUTPUT«4 6 6» | ||
smls | simply by having those use-cases that need it, exclicitly pass an item container as value, like ^^ | 20:37 | |
but not enforcing the item container by default | |||
TimToady | might be sane, post-GLR-wise | ||
20:38
yqt joined
|
|||
smls | then Enum would not be needed anymore | 20:39 | |
and EnumMap could be renamed to Map, like jnthn++ suggested | |||
and things would already start to look much more friendly in that part of the type hierarchy... :P | |||
20:41
virtualsue joined
|
|||
TimToady | m: my $p = pair((my $a),(my $b)); $a = 'a'; $b = 42; say $p | 20:44 | |
camelia | rakudo-moar a32c14: OUTPUT«(Any) => (Any)» | ||
TimToady | but in that case, something is deconting that shouldn't | ||
smls | all I know is that it works with pre-GLR Parcel, so surely it can be made to work with others... :P | 20:45 | |
TimToady --> oil change & | |||
20:50
jkva joined
|
|||
lizmat | m: my $p = Pair.new(:key(my $a),:value(my $b)); $a = "a"; $b = 42; say $p # the problem is with Pair.new, not necessarily with pair | 20:52 | |
camelia | rakudo-moar a32c14: OUTPUT«(Any) => (Any)» | ||
smls | imgur.com/a/DL1BE -- update 'associative' types chart, as well as a bonus chart for the 'positional' ones (just for context - those are perfectly fine IMO). | 20:54 | |
20:55
colomon left
20:56
llfourn joined
|
|||
japhb catches up with skimming last couple day's worth of backlog | 20:57 | ||
20:57
jkva left
|
|||
japhb | nine++ # Inline::Perl5, woot! | 20:57 | |
It sounds like you're getting closer and closer to "least surprise" for users | |||
jnthn++ # GLR coding machine | |||
20:59
diana_olhovik left
21:01
llfourn left
21:03
jkva joined
21:05
skids left
|
|||
ugexe | anyone taken a crack at rakudo on win10 IoT yet? | 21:05 | |
21:05
oetiker left
21:06
kaare_ left
21:09
jkva left
|
|||
dalek | ecs: 4b6a1fc | lizmat++ | S17-concurrency.pod: Kebab-case IO::Notification.watch_path Also simplify .IO.watch example |
21:10 | |
21:10
virtualsue left
21:13
rurban left
21:14
maettu left
21:16
colomon joined
21:18
diana_olhovik joined
|
|||
dalek | c: be54e6a | lizmat++ | lib/Type/Supply.pod: Document some more supply methods and reorganize the methods in more or less logical groups |
21:18 | |
21:23
diana_olhovik left
21:24
TEttinger joined
|
|||
dalek | ast: 29c7420 | lizmat++ | S17-supply/watch (2 files): Kebab-case watch_path, part 1 |
21:30 | |
21:30
raiph left
|
|||
dalek | ast: d3c4f3b | lizmat++ | S17-supply/watch-path.t: Kebab-case watch_path, part 2 |
21:31 | |
21:31
raiph joined
|
|||
ugexe | fwiw there is also $in_charge for the 2 ::Async modules | 21:32 | |
21:32
breinbaas left
|
|||
dalek | kudo/nom: 19890c7 | lizmat++ | / (6 files): Kebab-case IO::Notification.watch_path |
21:33 | |
lizmat | ugexe: that's internal though, isn't it ? | 21:34 | |
watch_path is outward facing | |||
ugexe | yeah | 21:35 | |
lizmat | so I think I've documented all of Supply's methods now | 21:36 | |
except classify / categorize | |||
I was looking at them, and I was thinking to myself: what idiot implemented *that* | |||
turns out, not only did I implement it, I also specced it :-) | |||
anyways, I have my doubts about the implementation now, need to look deeper into it before documenting it and thereby exposing it better to the world | 21:37 | ||
21:38
[Sno] joined
21:40
Zoffix joined
|
|||
japhb | Your harshest critic: your own future self | 21:45 | |
RabidGravy | I think it kinda works as it is, document, get people using it and take recommendations :) | ||
a working less than perfect thing is better than a not working ideal thing in these cases :) | 21:47 | ||
dalek | ecs: e155c08 | lizmat++ | S17-concurrency.pod: Speculate about Supply.throttle($elems,$seconds) |
21:48 | |
RabidGravy | that one's begging for an "atleast" relative, whereby the taps are called at minimum $secs apart however quickly new values are received | 21:53 | |
lizmat | are you suggesting treating taps differently? | 21:54 | |
I mean, that not all taps on a given Supply are treated equally? (as in see all values) ? | |||
re-reading: isn't that what Supply.batch does ? | 21:55 | ||
RabidGravy | dunno | ||
smls | RabidGravy: I think jnthn demoed something like that in one of his presentations; don't remember the method name though | 21:57 | |
lizmat | ah, start/migrate | ||
? | |||
21:58
colomon left
|
|||
lizmat | m: sub a(\:a) { } | 22:00 | |
camelia | rakudo-moar a32c14: OUTPUT«===SORRY!===Cannot invoke this object (REPR: P6opaque, cs = 0)» | ||
RabidGravy | er, no actually what I'm thinking is totally doable with throttle as described | ||
I'm just stupid is all | 22:01 | ||
22:02
jkva joined
|
|||
lizmat | will be travelling for ~ 20 hours in about 12 hours from now | 22:03 | |
will look at implementing it on the way | |||
for now, I'm going to get some sleep | 22:04 | ||
afk& | |||
22:07
jkva left
|
|||
dalek | ecs: 982edab | lizmat++ | S04-control.pod: Prevent some confusion re a b c |
22:08 | |
22:08
[particle] joined,
oetiker joined
|
|||
lizmat | really afk now | 22:10 | |
22:15
Zoffix left
22:22
Possum left,
Possum joined
22:23
bin_005 left
22:25
fxer left
22:27
colomon joined
22:30
jjido left
22:31
smls_ joined
22:32
smls left
22:34
leont joined
22:35
skids joined
22:41
bjz left
22:54
smls_ left,
Zoffix joined,
Psyche^_ joined
22:57
llfourn joined
22:59
Psyche^ left
23:02
llfourn left
23:07
spider-mario left
|
|||
RabidGravy | boom! must do sleep. toodlepip | 23:09 | |
flussence notes out loud that "Stage parse" on nom has gotten significantly slower (around 20%) since about 2 weeks ago | 23:13 | ||
23:16
RabidGravy left
23:27
Psyche^_ left,
Psyche^ joined
23:28
yqt left,
simcop2387 left
|
|||
flussence | ...and spectest shows a similarly large bump. I haven't been paying close attention to happenings lately though, maybe this is old news. | 23:30 | |
23:31
jjido joined
23:34
simcop2387 joined
|
|||
dalek | kudo-star-daily: c2c9b3c | coke++ | log/MoarVM- (4 files): today (automated commit) |
23:34 | |
rl6-roast-data: df8a889 | coke++ | / (9 files): today (automated commit) |
|||
skids | well, tests are growing in number. Though IIRC someone did trim the timeouts in the async stuff. | ||
23:35
geekosaur left,
jjido left
23:36
simcop2387 left
23:38
geekosaur joined
|
|||
flussence | I know I'm not being scientific here at all :) -- I did observe a downward trend over time even with thousands of new tests being added, but it's taken a sudden jump lately. | 23:38 | |
ShimmerFairy | Well, I did notice a very slight increase in startup time for perl6-m. Not that I have any measurements, but I figured that since I never notice startup differences, maybe it means something :) | 23:40 | |
23:40
simcop2387 joined
|
|||
ShimmerFairy | (I also haven't see Stage parse: go under 100s for a day or so now) | 23:40 | |
flussence | 72 here, it used to be about 56... | ||
ShimmerFairy | The new average for me seems to be 104s, where before it was in the high 90s. (Certainly makes me want to start logging CORE's stagestats so I can be moar scientific about it ☺) | 23:42 | |
23:48
Peter_R left,
telex left
23:50
telex joined
|