»ö« Welcome to Perl 6! | perl6.org/ | evalbot usage: 'p6: say 3;' or rakudo:, or /msg camelia p6: ... | irclog: irc.perl6.org or colabti.org/irclogger/irclogger_logs/perl6 | UTF-8 is our friend! Set by moritz on 22 December 2015. |
|||
00:04
Actualeyes left
|
|||
AlexDaniel | hm, what's the easiest way to split a range into several subranges? | 00:08 | |
00:08
cdg left
|
|||
samcv | rotor | 00:08 | |
you trying to thread it? | |||
AlexDaniel | yup | ||
[Coke] | any feedback on the levenstein search? | 00:09 | |
*levenshtein | |||
babydrop | [Coke]: some searches return a ton of results... will that levenshtein exacerbate the issue? | ||
AlexDaniel | [Coke]: how fast is it? What about using Sift4? | 00:10 | |
samcv | m: my $words = any(<PENGUIN>); (0..0x20000).».uniname.contains($words).say; say now - INIT now | ||
camelia | rakudo-moar 0c75e5: OUTPUT«any(True)0.58537436» | ||
samcv | that's fast | ||
m: my $words = any(<abethathetnahnet>); (0..0x20000).».uniname.contains($words).say; say now - INIT now | |||
camelia | rakudo-moar 0c75e5: OUTPUT«any(False)0.59398663» | ||
samcv | :) | 00:11 | |
half a second isn't bad | |||
[Coke] | AlexDaniel: fast enough? don't know what sift4 is. | ||
babydrop | samcv: that looks wrong. | ||
AlexDaniel | [Coke]: siderite.blogspot.com/2014/11/supe...tance.html | ||
samcv | is it | ||
babydrop | OK :) | ||
samcv | it could be. but it returns true for real words and false for words not in it | ||
BenGoldberg | m: my $words = any(<GUN LAGAR>); (0..0x20000).».uniname.contains($words).say; say now - INIT now | ||
camelia | rakudo-moar 0c75e5: OUTPUT«any(True, True)0.6326179» | ||
timotimo | sounds like it'd stringify the names of all those characters into a single string | ||
babydrop | samcv: you're calling .contains on one huge string | ||
AlexDaniel | [Coke]: it's like levenshtein but much faster | ||
samcv | yes | 00:12 | |
babydrop | .oO( premature optimization... ) |
||
AlexDaniel | [Coke]: for example, we're using in on whateverables (even though we didn't need any speed boost) | ||
it* | |||
samcv | well that's the theoretical maximum speed it can go babydrop | ||
doing contains on one string | |||
timotimo | i see no post on the advent calendar blog yet; they're supposed to go up around this time, right? | 00:13 | |
BenGoldberg | m: my @props; my @words = any <GUN LAGAR>; my $results = (^0x20000).grep: { (@props ?? .uniprop.contains(@props.any) !! True) and (@words ?? .uniname.contains(@words.any) !! True) }; say +$results; say now - INIT now; | ||
camelia | rakudo-moar 0c75e5: OUTPUT«738.45589095» | ||
babydrop | timotimo: "in 3 hours" | ||
00:14
mawkish left
|
|||
babydrop forgets if RabidGravy ever confirmed his | 00:14 | ||
00:14
mawkish joined
|
|||
[Coke] | AlexDaniel: current version seems fast enough. I'm more concerned about user visible breakages. | 00:15 | |
BenGoldberg | m: say so any( map { print "foo"; True }, ^5 ); | ||
camelia | rakudo-moar 0c75e5: OUTPUT«foofoofoofoofooTrue» | ||
AlexDaniel | [Coke]: sure, that's just an idea | ||
BenGoldberg | m: my $its_a_seq = map { print "foo"; True }, ^5; say "bar"; | 00:16 | |
camelia | rakudo-moar 0c75e5: OUTPUT«bar» | ||
[Coke] | (easy enough to switch out with a new algorithm if someone wants, though) | ||
BenGoldberg | m: my $its_a_seq = map { print "foo"; True }, ^5; say any($its_a_seq); | ||
camelia | rakudo-moar 0c75e5: OUTPUT«foofoofoofoofooany(True, True, True, True, True)» | ||
BenGoldberg | m: my $its_a_seq = map { print "foo"; True }, ^5; my $my_bad = any($its_a_seq); say "bar"; | 00:17 | |
camelia | rakudo-moar 0c75e5: OUTPUT«foofoofoofoofoobar» | ||
babydrop | merge it :} | ||
BenGoldberg | Would anything break if any(Seq) did not unlazy the contents of the Seq? | 00:18 | |
timotimo | babydrop: huh, really? interesting. | ||
timotimo is currently reading the previous post, about QAST | |||
00:20
girafe left
00:22
girafe joined
|
|||
AlexDaniel | I have a feeling that this is not going to fit | 00:22 | |
m: my @props; my @words = <PENGUIN>; my $x = (0..0x1FFFF).rotor(0x1FFFF/8); .uniname.say for flat await ( for (@$x) { start { .grep( -> $z { !@words.first({ not uniname($z).contains($_)}) and !@props.first({uniprop($z) ne $_}) } ) } }); say now - INIT now | |||
camelia | rakudo-moar 0c75e5: OUTPUT«PENGUIN2.8917120» | ||
AlexDaniel | hm | 00:23 | |
00:23
Actualeyes joined
|
|||
AlexDaniel | eval: my @props; my @words = <PENGUIN>; my $x = (0..0x1FFFF).rotor(0x1FFFF/8); .uniname.say for flat await ( for (@$x) { start { .grep( -> $z { !@words.first({ not uniname($z).contains($_)}) and !@props.first({uniprop($z) ne $_}) } ) } }); say now - INIT now | 00:23 | |
evalable6 | AlexDaniel, rakudo-moar 0c75e5d: OUTPUT«PENGUIN3.1004866» | ||
AlexDaniel | eval: my @props; my @words = <PENGUIN>; my $x = (0..0x1FFFF).rotor(0x1FFFF/8); .uniname.say for flat await ( for (@$x) { start { .grep( -> $z { !@words.first({ not uniname($z).contains($_)}) and !@props.first({uniprop($z) ne $_}) } ) } }); say now - INIT now | ||
evalable6 | AlexDaniel, rakudo-moar 0c75e5d: OUTPUT«PENGUIN3.0042219» | ||
AlexDaniel | eval: my @props; my @words = <PENGUIN>; my @a; for (0..0x1FFFF).grep(-> $z { (!@words.first({ not uniname($z).contains($_)})) and (!@props.first({uniprop($z) ne $_})) }) { .uniname.say }; say now - INIT now | ||
evalable6 | AlexDaniel, rakudo-moar 0c75e5d: OUTPUT«PENGUIN1.7202091» | ||
AlexDaniel | eval: my @props; my @words = <PENGUIN>; my $x = (0..0x1FFFF).rotor(0x1FFFF/4); .uniname.say for flat await ( for (@$x) { start { .grep( -> $z { !@words.first({ not uniname($z).contains($_)}) and !@props.first({uniprop($z) ne $_}) } ) } }); say now - INIT now | ||
evalable6 | AlexDaniel, rakudo-moar 0c75e5d: OUTPUT«PENGUIN2.62765727» | ||
AlexDaniel | eval: my @props; my @words = <PENGUIN>; my $x = (0..0x1FFFF).rotor(0x1FFFF/2); .uniname.say for flat await ( for (@$x) { start { .grep( -> $z { !@words.first({ not uniname($z).contains($_)}) and !@props.first({uniprop($z) ne $_}) } ) } }); say now - INIT now | 00:24 | |
evalable6 | AlexDaniel, rakudo-moar 0c75e5d: OUTPUT«PENGUIN2.4436951» | ||
AlexDaniel | ok enough | ||
well screw it then, let's say 1.72 is good enough | |||
tbrowder | babydrop: i'm looking for my advent post and something is wrong--should be showing up now, no? | 00:25 | |
00:26
lucasb left
|
|||
timotimo | apparently it's scheduled to show up in 3 hours | 00:26 | |
babydrop | tbrowder: it's scheduled for 3 hours from now | ||
timotimo | Scheduled for: Dec 12, 2016 @ 02:58 Edit | 00:27 | |
tbrowder | ok, i can't find it anywhere in wordpresss--had me worried | ||
timotimo | right, only findable in the admin | ||
perl6advent.wordpress.com/wp-admin/edit.php - this part of the admin console has it | |||
tbrowder | whew, thanks! | 00:28 | |
babydrop sees it in wordpress.com/posts/scheduled/perl...dpress.com | |||
You just have to select "Everyone" instead of just "Me" | 00:29 | ||
[Coke] | m: / ',' <-[ ]> / | ||
camelia | rakudo-moar 0c75e5: OUTPUT«===SORRY!===Iteration past end of iterator» | ||
[Coke] | That seems LTA> | 00:30 | |
timotimo | oh, good find | ||
tbrowder | hm, no wonder wordpress sucks rocks... | ||
we definitely need our own system... | |||
00:32
mawkish left,
mawkish joined
|
|||
babydrop | m: /<-[]>/ | 00:33 | |
camelia | rakudo-moar 0c75e5: OUTPUT«===SORRY!===Iteration past end of iterator» | ||
babydrop | m: /<[]>/ | ||
camelia | ( no output ) | ||
[Coke] | m: / <-[ ]> / | ||
camelia | rakudo-moar 0c75e5: OUTPUT«===SORRY!===Iteration past end of iterator» | ||
timotimo | tbrowder: are you going to make the post released now? | ||
tbrowder | no...trusting to the system unless it should be--that was the scheduled time that popped up when i scheduled it--i dodn't have any control over the time that i could see | 00:35 | |
timotimo | strange | 00:37 | |
tbrowder | i guess i can force it--should i? | ||
timotimo | anyway, i just read the scheduled version and am going to bed now :) | ||
so to me it makes no difference now :P | |||
samcv | oh AlexDaniel i fixed the problem | 00:40 | |
we can do it in | |||
00:40
wamba left
|
|||
samcv | like .2 seconds | 00:40 | |
hold on | |||
00:41
mawkish left
00:42
mawkish joined
|
|||
AlexDaniel | yea, I think I have it too | 00:43 | |
samcv | oh crap. i think you have to supply the exact name for this nqp operation | ||
oh well | |||
would have been nice | |||
AlexDaniel | with nqp ops, huh? | 00:44 | |
samcv | yeah | ||
AlexDaniel | m: my @props; my @words = <PENGUIN>; my $sieve = 0..0x1FFFF; for @words -> $word { $sieve = (@$sieve).grep({uniname($_).contains($word)}) }; for @props -> $prop { $sieve = (@$sieve).grep({uniprop($_) eq $prop}) }; .uniname.say for @$sieve; say now - INIT now | ||
samcv | it does it like. | ||
camelia | rakudo-moar 0c75e5: OUTPUT«PENGUIN0.68539801» | ||
AlexDaniel | here | ||
eval: my @props; my @words = <PENGUIN>; my $sieve = 0..0x1FFFF; for @words -> $word { $sieve = (@$sieve).grep({uniname($_).contains($word)}) }; for @props -> $prop { $sieve = (@$sieve).grep({uniprop($_) eq $prop}) }; .uniname.say for @$sieve; say now - INIT now | |||
evalable6 | AlexDaniel, rakudo-moar 0c75e5d: OUTPUT«PENGUIN0.584401» | ||
samcv | m: use nqp; nqp::codepointfromname.say; say now - INIT now | ||
camelia | rakudo-moar 0c75e5: OUTPUT«===SORRY!===Arg count 0 doesn't equal required operand count 2 for op 'getcpbyname'» | ||
samcv | m: use nqp; nqp::codepointfromname('PENGUIN').say; say now - INIT now | 00:45 | |
camelia | rakudo-moar 0c75e5: OUTPUT«1280390.01494175» | ||
samcv | .01 seconds | ||
AlexDaniel | :-| | ||
babydrop | m: eager ^0x20000; say now - INIT now | ||
camelia | rakudo-moar 0c75e5: OUTPUT«0.05801395» | ||
AlexDaniel | yea, that would be nice | ||
samcv | AlexDaniel, would be cool if it tried that operation first and if so reply with that instantly | ||
babydrop | m: eager (^0x20000)».uniname; say now - INIT now | ||
camelia | rakudo-moar 0c75e5: OUTPUT«0.49742634» | ||
AlexDaniel | samcv: 0.59s is kinda like instantly | ||
babydrop | Create the list once on startup? | ||
And use the uninamed version for all lookups | 00:46 | ||
AlexDaniel | babydrop: ooooooooooooooooooh | ||
samcv | my bot in another channel does that | ||
it creates a hash of all of them | |||
AlexDaniel | right, now I remember | ||
samcv | but that's not the main reason the bot is slow though | ||
it won't speed it up that much | |||
AlexDaniel | come on, 0.59s! That's super fast! | 00:47 | |
samcv | oh | ||
my @props; my @words = <PENGUIN>; my $sieve = 0..0x1FFFF; for @words -> $word { $sieve = (@$sieve).grep({uniname($_).contains($word)}) }; for @props -> $prop { $sieve = (@$sieve).grep({uniprop($_) eq $prop}) }; .uniname.say for @$sieve; say now - INIT now | |||
this? | |||
AlexDaniel | yes | ||
samcv | m: my @props; my @words = <PENGUIN>; my $sieve = 0..0x1FFFF; for @words -> $word { $sieve = (@$sieve).grep({uniname($_).contains($word)}) }; for @props -> $prop { $sieve = (@$sieve).grep({uniprop($_) eq $prop}) }; .uniname.say for @$sieve; say now - INIT now | ||
camelia | rakudo-moar 0c75e5: OUTPUT«PENGUIN0.6941767» | ||
samcv | yeah that is fast | ||
SmokeMachine | m: Int ~~ UInt | 00:48 | |
camelia | rakudo-moar 0c75e5: OUTPUT«Invocant requires an instance of type Int, but a type object was passed. Did you forget a .new? in any accepts_type at gen/moar/Metamodel.nqp line 3435 in block <unit> at <tmp> line 1» | ||
samcv | yeah that's good | ||
SmokeMachine | is this expected? | ||
samcv | m: my @props; my @words = <STAR>; my $sieve = 0..0x1FFFF; for @words -> $word { $sieve = (@$sieve).grep({uniname($_).contains($word)}) }; for @props -> $prop { $sieve = (@$sieve).grep({uniprop($_) eq $prop}) }; .uniname.say for @$sieve; say now - INIT now | ||
camelia | rakudo-moar 0c75e5: OUTPUT«START OF HEADINGSTART OF TEXTSTART OF SELECTED AREASTART OF GUARDED AREASTART OF STRINGARABIC FIVE POINTED STARARABIC START OF RUB EL HIZBTIBETAN MARK DELIMITER TSHEG BSTARSTAR EQUALSSTAR OPERATORAPL FUNCTIONAL SYMBOL CIRCLE S…» | ||
samcv | cool | ||
AlexDaniel | hm wait | 00:49 | |
babydrop | SmokeMachine: could be improved | ||
AlexDaniel | m: my @props; my @words = <PENGUIN>; my $sieve = 0..0x1FFFF; for @words -> $word { $sieve .= grep({uniname($_).contains($word)}) }; for @props -> $prop { $sieve .= grep({uniprop($_) eq $prop}) }; .uniname.say for @$sieve; say now - INIT now | ||
camelia | rakudo-moar 0c75e5: OUTPUT«PENGUIN0.19691999» | ||
samcv | does it find all the words though? | ||
babydrop | m: &infix:<~~>, \(Int, UInt) | ||
camelia | rakudo-moar 0c75e5: OUTPUT«WARNINGS for <tmp>:Useless use of &infix:<~~> in sink context (lines 1, 1)» | ||
babydrop | SmokeMachine: but to answer the question: yes, UInt is a subset of Int | 00:50 | |
d: &infix:<~~>, \(Int, UInt) | |||
s: &infix:<~~>, \(Int, UInt) | |||
SourceBaby | babydrop, Sauce is at github.com/rakudo/rakudo/blob/0c75...Mu.pm#L821 | ||
AlexDaniel | eval: my @props; my @words = <A B C D>; my $sieve = 0..0x1FFFF; for @words -> $word { $sieve .= grep({uniname($_).contains($word)}) }; for @props -> $prop { $sieve .= grep({uniprop($_) eq $prop}) }; .uniname.say for @$sieve; say now - INIT now | ||
evalable6 | AlexDaniel, rakudo-moar 0c75e5d: OUTPUT«END OF TRANSMISSION BLOCKPARTIAL LINE BACKWARDLATIN CAPITAL LETTER C WITH DOT ABOVELATIN SM…» | ||
AlexDaniel, Full output: gist.github.com/c2459aed25182d894c...c77e8a41e8 | |||
AlexDaniel | unicodable6: A B C D | ||
unicodable6 | AlexDaniel, U+0017 END OF TRANSMISSION BLOCK [Cc] (␗) | ||
AlexDaniel, U+008C PARTIAL LINE BACKWARD [Cc] () | |||
AlexDaniel, U+010A LATIN CAPITAL LETTER C WITH DOT ABOVE [Lu] (Ċ) | |||
AlexDaniel, gist.github.com/ | 00:51 | ||
AlexDaniel | thank you very much! | ||
samcv: yes, these are all! | 00:53 | ||
samcv | sweet | ||
SmokeMachine | babydrop: thanks... | 00:54 | |
00:56
kyclark joined
|
|||
AlexDaniel | samcv: how can it be so much faster, I don't get it :o | 00:56 | |
samcv | hmm | 00:57 | |
it is awesome tho | |||
but interesting how much faster it is | |||
but uniname is really fast tho | |||
it goes straight through almost to moarvm | 00:58 | ||
AlexDaniel | samcv: about 9 times | ||
than the current version of unicodable | |||
samcv | yeah | ||
i mean it's really fast, i mean even uniprop which is a lil slower | |||
takes 8 seconds on my laptop to go through all unicode symbols 10 times | |||
so 10 times 0x1FFFF | 00:59 | ||
it's always been the .contains part and calling it so many times, but. i think | |||
it's because no junctions | |||
^ | 01:00 | ||
babydrop | SmokeMachine: wanna fix that bug? | ||
samcv | at least a big part | ||
babydrop | SmokeMachine: it fails in this check: github.com/rakudo/rakudo/blob/nom/.../Int.pm#L6 | ||
SmokeMachine: and it should be where { not .defined or $_ >= 0 }; | |||
SmokeMachine | is it only that? | 01:01 | |
babydrop: ^^ | |||
01:02
canopus left
|
|||
babydrop | SmokeMachine: yup | 01:02 | |
m: Int >= 0 | |||
camelia | rakudo-moar 0c75e5: OUTPUT«WARNINGS for <tmp>:Useless use of ">=" in expression "Int >= 0" in sink context (line 1)Invocant requires an instance of type Int, but a type object was passed. Did you forget a .new? in block <unit> at <tmp> line 1» | ||
babydrop | m: quietly Int >= 0 | ||
camelia | rakudo-moar 0c75e5: OUTPUT«WARNINGS for <tmp>:Useless use of ">=" in expression "Int >= 0" in sink context (line 1)Invocant requires an instance of type Int, but a type object was passed. Did you forget a .new? in block <unit> at <tmp> line 1» | ||
babydrop | I said quietly! | ||
timotimo | that's a compile-time warning :P | ||
01:02
_28_ria joined
|
|||
babydrop | SmokeMachine: basically in Int ~~ UInt, the Int type object goes into that where and tries to do Int >= 0, but there's no such candidate. So the `not .defined ` would accept undefined UInts | 01:03 | |
well... undefined Ints | |||
SmokeMachine | babydrop: I got it! :) | ||
01:03
_28_ria left
|
|||
SmokeMachine | babydrop: can I try to fiz that? | 01:03 | |
*fix | 01:04 | ||
samcv | m: my subset UInt of Int where * >= 0 or *.defined; (UInt ~~ Int).say | ||
camelia | rakudo-moar 0c75e5: OUTPUT«True» | ||
samcv | that fixes it | ||
01:04
_28_ria joined
01:05
kyclark left
|
|||
babydrop | ummm | 01:05 | |
hehehe | |||
samcv: I see three mistakes :} | |||
samcv | yeah | ||
i just noticed | |||
01:05
kyclark joined
|
|||
samcv | ha | 01:05 | |
babydrop | samcv: the where * >= 0 or *.defined takes 2 args, so you're not checking the same arg | 01:06 | |
samcv | yeah | ||
it was poorly thought out | |||
babydrop | But it works! :P | ||
samcv | m: my subset UInt of Int; | 01:07 | |
camelia | ( no output ) | ||
samcv | fixed^ | ||
i have often thought about creating a perl 6 implementation which only implements roast | |||
TimToady | m: (* >= 0 or *.defined).arity.say | ||
camelia | rakudo-moar 0c75e5: OUTPUT«1» | ||
01:07
canopus joined
|
|||
samcv | and hardcodes all the values | 01:07 | |
babydrop | :o | ||
TimToady | * doesn't go past 'or' | 01:08 | |
babydrop | Thanks. | ||
SmokeMachine | babydrop: should I create any test? | ||
AlexDaniel | samcv: interesting. You can probably automate a lot of it | ||
samcv | this 'perl6 implementation' would have to be recompiled for every new roast, but | ||
babydrop | SmokeMachine: of course! That's the only way you know the fix works :) | ||
AlexDaniel | samcv: I wonder if it would be able to run any user code | ||
samcv | doubtful | ||
unless like | |||
you typed exactly the same thing as roast tested | 01:09 | ||
AlexDaniel | depends on the values you use :D | ||
samcv | because all values are hardcoded | ||
yeah | |||
SmokeMachine | babydrop: Where? (Im sorry about so many questions... but thats my first time... :)) | ||
samcv | oh in roast SmokeMachine | 01:10 | |
babydrop | SmokeMachine: it's cool | ||
01:10
kyclark left
|
|||
samcv | in S32-num/int.t i think | 01:10 | |
SmokeMachine | samcv: roast is a different repo, isn't it? How should I do that? | ||
babydrop | SmokeMachine: the test goes into github.com/perl6/roast The way I do it is `tree -f | grep -i` some term.. In this case I'd use `tree -f | grep -i uint` which gives S02-types/int-uint.t | 01:11 | |
SmokeMachine: fork it, and in your rakudo repo, do git clone URL-TO-THE-FORK t/spec | |||
And to run it do make spectest | |||
SmokeMachine | ok! doing that! | 01:12 | |
babydrop | And to run individual file run make t/spec/S02-types/int-uint.t after you add your test | ||
samcv | babydrop, that info should be in the README | ||
tbqh | |||
babydrop | samcv: I think it is. But I also plan to make contribute.perl6.org a web app that has all this info in an interactive way sortof | ||
github.com/perl6/contribute/blob/m.../DESIGN.md | 01:13 | ||
samcv | it's not in there babydrop | ||
somebody who knows more about roast than i do should add it, since i just ran the tests individually before :P | |||
babydrop | oh | ||
01:13
TEttinger joined
01:14
unicodable6 left,
unicodable6 joined
|
|||
AlexDaniel | unicodable6: butterfly | 01:14 | |
unicodable6 | AlexDaniel, U+1F98B BUTTERFLY [So] (🦋) | ||
AlexDaniel | YEA! THAT'S MUCH BETTER! | ||
fucking instant! | |||
babydrop | SmokeMachine: I see that file is actually for native uints. Unless you already started adding to it, add S32-num/int.t instead (yeah, the organization of the repo isn't perfect) | ||
samcv: which info isn't in the README btw? | 01:15 | ||
About how to find files? | |||
AlexDaniel | unicodable6: gun lagar | ||
unicodable6 | AlexDaniel, U+12006 CUNEIFORM SIGN A TIMES LAGAR GUNU [Lo] (𒀆) | ||
AlexDaniel, U+121EF CUNEIFORM SIGN LAGAR GUNU [Lo] (𒇯) | |||
AlexDaniel, U+121F0 CUNEIFORM SIGN LAGAR GUNU OVER LAGAR GUNU SHE [Lo] (𒇰) | |||
samcv | no | ||
how to make spectest | |||
SmokeMachine | ok! closing the old file... opening the new one... | ||
babydrop | unicodable6: non-breaking space | ||
unicodable6 | babydrop, U+006E LATIN SMALL LETTER N [Ll] (n) | ||
babydrop, U+006F LATIN SMALL LETTER O [Ll] (o) | |||
babydrop, gist.github.com/a0f764a96c23c55200...73cce71dcf | |||
samcv | about how to RUN them | ||
it says everything else | |||
babydrop | Right. | ||
samcv | hah | ||
AlexDaniel | u: breaking space | 01:16 | |
01:16
mawkish left
|
|||
unicodable6 | AlexDaniel, Found nothing! | 01:16 | |
AlexDaniel | u: break space | ||
unicodable6 | AlexDaniel, U+00A0 NO-BREAK SPACE [Zs] ( ) | ||
AlexDaniel, U+202F NARROW NO-BREAK SPACE [Zs] ( ) | |||
AlexDaniel, U+FEFF ZERO WIDTH NO-BREAK SPACE [Cf] () | |||
AlexDaniel | ok, digits, dash… | ||
babydrop | It's cause I wrote "breaking" instead of "break" :) | ||
AlexDaniel | no it's cause you wrote - | ||
babydrop | Oh :( | ||
u: non breaking space | 01:17 | ||
unicodable6 | babydrop, Found nothing! | ||
AlexDaniel | I can fix that real quick | ||
babydrop | u: breaking space | ||
unicodable6 | babydrop, Found nothing! | ||
AlexDaniel | but | ||
babydrop | samcv: I see there's another way to run the tests in the repo: github.com/perl6/roast/blob/master...IBUTING.md | ||
AlexDaniel | eval: 0x1FFFF.map({.uniname}).comb.sort.squish.say | 01:18 | |
evalable6 | AlexDaniel, rakudo-moar 0c75e5d: OUTPUT«(< > a e g i l)» | ||
babydrop | Well, it shouldn't go to roast repo anyway, because it's just Rakudo's way of running tests. It should be in Rakudo docs or, as I've said, in contributing.rakudo.org | ||
AlexDaniel | eval: (0..0x1FFFF).map({.uniname}).comb.sort.squish.say | ||
I know I should use bags, but… | |||
evalable6 | AlexDaniel, rakudo-moar 0c75e5d: OUTPUT«(signal SIGHUP) «timed out after 10 seconds, output»: » | ||
01:18
mawkish joined
|
|||
AlexDaniel | or what should I use? | 01:18 | |
babydrop | For what? | ||
AlexDaniel | babydrop: I want to have all characters used in uninames | 01:19 | |
samcv | AlexDaniel, split on '-' | ||
please | |||
er. i guess | |||
babydrop | eval: (0..0x1FFFF).map({.uniname}).flat.comb.Bag.map(*.keys).say | ||
samcv | it finds anyway | 01:20 | |
hmm so probably won't change anything maybe | |||
evalable6 | babydrop, rakudo-moar 0c75e5d: OUTPUT«(signal SIGHUP) «timed out after 10 seconds, output»: » | ||
babydrop | eval: (0..0x1FFFF)».uniname.join.comb.Bag.map(*.keys).say | ||
evalable6 | babydrop, rakudo-moar 0c75e5d: OUTPUT«(signal SIGHUP) «timed out after 10 seconds, output»: » | ||
samcv | it's gonna all timeout | ||
babydrop gives up | |||
samcv | it's gonna take time to create it | ||
AlexDaniel, what do you mean you want to have all characters | 01:21 | ||
individually? | |||
babydrop | eval: (% {(0..0x1FFFF)».uniname.comb}).keys.join.say | ||
evalable6 | babydrop, rakudo-moar 0c75e5d: OUTPUT«(exit code 1) ===SORRY!=== Error while compiling /tmp/O4h3lMrUyPUnexpected block in infix pos…» | ||
babydrop, Full output: gist.github.com/d5717badcc8e4ab6eb...646f0fd1a7 | |||
AlexDaniel | I want to know which ones are used :) | ||
samcv | oh | ||
i see | |||
AlexDaniel | I can probably look it up but… it's not fun this way | ||
SmokeMachine | babydrop: sorry again, but How do I run the tests? | 01:22 | |
I tried with prove -e perl6 but I realized that was using my installed perl6 (I suppose) | 01:23 | ||
01:24
aborazmeh joined,
aborazmeh left,
aborazmeh joined
|
|||
babydrop | SmokeMachine: did you build rakudo with the fix in it? | 01:24 | |
SmokeMachine | not yet... | ||
samcv | eval: (0..0x1FFFF).map({.uniname}).ords.Bag.say | ||
evalable6 | samcv, rakudo-moar 0c75e5d: OUTPUT«(signal SIGHUP) «timed out after 10 seconds, output»: » | ||
samcv | the Bag part makes it slow | ||
babydrop | SmokeMachine: build it. And then in rakudo's repository run `make t/spec/the-file-you-added-the-test-to.t` and it'll run it | 01:25 | |
And also run `make spectest` to ensure the fix doesn't break anything | |||
SmokeMachine | babydrop: should I follow the REDME? | ||
AlexDaniel | samcv: well, that's not how it should be used, I guess :) | ||
I was hoping that something like this will work | |||
babydrop | SmokeMachine: if it describes the process, sure. | ||
AlexDaniel | eval: my $set = SetHash.new; for 0..0x1FFFF { $set{.uniname.comb} = 1 xx * }; say $set | ||
SmokeMachine | :) | ||
evalable6 | AlexDaniel, rakudo-moar 0c75e5d: OUTPUT«(signal SIGHUP) «timed out after 10 seconds, output»: » | ||
AlexDaniel | eval: my %c; for 0..0x1FFFF { %c{$_} = 1 for .uniname.comb }; .say for sort keys %c | 01:27 | |
evalable6 | AlexDaniel, rakudo-moar 0c75e5d: OUTPUT« ()-0123456789<>ABCDEFGHIJKLMNOPQRSTUVWXYZabdeghilnoprstuvwxy» | ||
AlexDaniel | there we go | ||
dalek | c: 300f3e8 | coke++ | xt/trailing-whitespace.t: fix indent |
01:28 | |
c: d385536 | coke++ | doc/Language/glossary.pod6: Don't use quotes, avoid ", interaction |
|||
synopsebot6 | Link: doc.perl6.org/language/glossary | ||
c: a103ca2 | coke++ | doc/ (5 files): avoid trailing comma before closing paren |
|||
SmokeMachine | Does anyone know it I am doing something wrong? | ||
babydrop | Kinda sucks there aren't any goodlooking methods for adding stuff to hash | ||
SmokeMachine | www.irccloud.com/pastebin/eJXhcHk0/ | ||
now just worked! | |||
babydrop | *adding stuff to SetHash I mean | 01:29 | |
something like $s.add: <some items> | |||
m: my $s = SetHash.new; $s.push: 42; dd $s | |||
camelia | rakudo-moar 0c75e5: OUTPUT«Cannot resolve caller push(SetHash: Int); none of these signatures match: (Any:U \SELF: |values is raw) in block <unit> at <tmp> line 1» | ||
babydrop | huh | ||
m: my $s = SetHash; $s.push: 42; dd $s | 01:30 | ||
camelia | rakudo-moar 0c75e5: OUTPUT«Array $s = $[42]» | ||
babydrop | 0.o | ||
Oh right | |||
autoviv candidate | |||
samcv | AlexDaniel, ords is going to be faster than comb | ||
and it's all ascii | |||
so i'd use .ords and then sort by the number of things it found then print it out as characters | |||
dalek | ateverable: 1ba7473 | (Aleks-Daniel Jakimenko-Aleksejev)++ | Unicodable.p6: Make Unicodable 9 times faster Not sure why would it be so much faster, but whatever. Now every query runs under one second. |
01:32 | |
AlexDaniel | u: { .uniname.contains(‘(’) } | 01:33 | |
unicodable6 | AlexDaniel, U+000C FORM FEED (FF) [Cc] (␌) | ||
AlexDaniel, U+0085 NEXT LINE (NEL) [Cc] () | |||
AlexDaniel, U+000D CARRIAGE RETURN (CR) [Cc] (␍) | |||
AlexDaniel, gist.github.com/d031ddf8f221742bda...dcfee26f2f | |||
AlexDaniel | well, amazing gist | 01:34 | |
01:35
travis-ci joined
|
|||
travis-ci | Doc build failed. Will "Coke" Coleda 'avoid trailing comma before closing paren | 01:35 | |
travis-ci.org/perl6/doc/builds/183135040 github.com/perl6/doc/compare/b7f0e...03ca242da4 | |||
01:35
travis-ci left
01:38
mawkish left,
mawkish joined
|
|||
babydrop | that l |