»ö« 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.
00:00 telex left
RabidGravy right enough of this, nighty night people 00:01
00:02 telex joined 00:03 llfourn left
dalek kudo-star-daily: 9f688a2 | coke++ | log/ (9 files):
today (automated commit)
 00:05
rl6-roast-data: 182ff9f | coke++ | / (10 files):
today (automated commit)
00:05 RabidGravy left 00:06 yqt left 00:34 lizmat joined
lizmat good * from YAPC::Asia 00:34
00:36 mjgardner left 00:41 cibs_ joined 00:43 mjgardner joined
jdv79 ok 00:47
00:47 vendethiel left 00:52 mjgardner left 00:54 mjgardner joined
lizmat Larry just began... 00:56
00:58 colomon left
AlexDaniel at least there will be a video, right? 01:00
yoleaux 20 Aug 2015 10:01Z <FROGGS> AlexDaniel: I think timotimo meant the state we already had when we spoke last time
AlexDaniel because I was a little bit disappointed because of fosdem…
and I am a bit unhappy because of qx// 01:02
:)
lizmat trying to make a video right now :-) 01:03
01:04 colomon joined 01:15 jkva joined, colomon left, colomon joined 01:17 aborazmeh left 01:19 jkva left 01:20 cibs joined 01:22 khw joined 01:24 cibs_ left 01:25 aborazmeh joined, aborazmeh left, aborazmeh joined 01:35 aborazmeh left 01:37 dayangkun joined 01:41 hryk joined 01:42 hryk left 01:54 aborazmeh joined, lizmat left, aborazmeh left, aborazmeh joined 01:56 lizmat joined
lizmat argh... camera kicks out every 20 mins or so, stupid EU regulations 01:57
so missed a few seconds twice
not sure how good the audio is
it *was* an audience recording :-)
colomon EU regulations? 01:58
lizmat video cameras are taxed much higher than still cameras
colomon :(
lizmat so you buy a still camera with a video feature
it is only allowed to record 20 mins max 01:59
or it will be taxed as a video camera
and become 20% more expensive
01:59 llfourn joined
colomon yow! 02:00
lizmat yeah
they *are* hacks to change the firmware to allow longer recording
but I just never bothered :-( 02:01
colomon should just buy a camera next time you’re in the states. ;) 02:02
lizmat come to think of it, this camera *was* bought in the States 02:04
maybe there are similar regulations?
colomon huh not that I know of?
www.tested.com/tech/photography/444...ing-limit/ 02:06
not really a good explanation
honoring the EU regs just because it’s convenient for them? 02:07
photo.stackexchange.com/questions/1...e-duration 02:08
02:08 lizmat left 02:09 lizmat joined
lizmat well, that was a hard crash. 2nd time this week :-( 02:09
timotimo I had a rather hard crash today too... 02:14
02:16 mjgardner left 02:26 noganex_ joined 02:28 noganex left 02:34 vendethiel joined 02:35 inokenty joined, mr-foobar left
dalek kudo/glr: a49eb3d | lizmat++ | tools/build/makeSLICE.pl6:
Fix deprecation when generating new slice code
 02:40
cognominal colomon, the media industry seems to make the law in Europe. At least, with a pirate deputy with a very conservative proposal in the european parlement, one can see in action with their proposed amendments. 02:47
02:48 aborazmeh left
lizmat looking at why multi-element hash slices don't work in GLR 02:50
it looks like the $more value is containerized one level too many 02:51
$ 6 'my %h = a => [1,2,3], b => 42; say (%h<a b>:delete).perl'
$more = \(("a", "b"))
$ 6 'my @a = [1,2,3],42; say (@a[0,1]:delete).perl'
$more = $(0, 1)
adding a $more = $more[0] in the hash case gives me: 02:54
$ 6 'my %h = a => [1,2,3], b => 42; say (%h<a b>:delete).perl'
($[1, 2, 3], 42)
as expected
since the postcircumfix is just passing on \key 02:55
hmmm... 02:56
argh, looks like we had a typo there for a *long* time that was hidden by excessive flattening 02:57
dalek kudo/glr: fa0c50c | lizmat++ | src/core/hash_slice.pm:
Fix an old thinko that was uncovered by GLR

This should fix all has slices (at least for now)		 03:00
lizmat *hash
03:03 vendethiel left 03:04 kaare_ joined 03:05 mr-foobar joined 03:07 AlexDaniel left
dalek kudo/glr: 7f6f85d | lizmat++ | src/core/hash_slice.pm:
Fix (for now) hash zen/whatever slices

Perhaps we should do this in SLICE_MORE_HASH, not sure yet		 03:08
ShimmerFairy I personally love when fixing things uncovers bugs that managed to slip by :) 03:09
lizmat yeah, and the extra Capture creation / flattening that was done, was not good for performance :-) 03:10
03:10 aborazmeh joined, aborazmeh left, aborazmeh joined
ShimmerFairy lizmat: looking at that thinko, would a warning on using \var for declared sigil-less vars be useful or too superfluous? (e.g. warn on the second \a in my \a = 42; say \a ) 03:13
03:13 lizmat left, CQ_ joined
ShimmerFairy On the one hand it seems like it would be silly to add a warning for that, but on the other hand I do get the feeling that a lot of people could trip up on thinking \ was just another sigil there. 03:15
03:15 CQ left, CQ_ is now known as CQ 03:19 BenGoldberg joined, BenGoldberg left 03:35 fling joined 03:43 cantaberry joined
skids thinks we need an opt-in category of warnings, and it should go there. 03:49
btw this needs error to be demoted similarly: 03:51
m: my $a = {}; $a.perl.say; {}.perl.say; EVAL '${}';
GLRelia rakudo-moar 7f6f85: OUTPUT«${}␤{}␤5===SORRY!5=== Error while compiling EVAL_0␤Unsupported use of ${}; in Perl 6 please use $()␤at EVAL_0:1␤------> 3${}7⏏5<EOL>␤»
camelia rakudo-moar 815fff: OUTPUT«{}␤{}␤5===SORRY!5=== Error while compiling EVAL_0␤Unsupported use of ${}; in Perl 6 please use $()␤at EVAL_0:1␤------> 3${}7⏏5<EOL>␤»
ShimmerFairy skids: I think everything that's disallowed on the basis of me expecting P5 behavior should be removable, since I don't know that :) 03:59
skids: I frequently think that 'use/no warnings' should be given options based on category, like gcc's -W flags
04:00 lizmat joined
japhb ShimmerFairy: Would you accept the idea of disallowing P5 behavior for 6.Christmas, and then allowing reuse in 6.Future? 04:00
ShimmerFairy e.g. 'no warnings :Perl5' or 'yes warnings :sigilless' (I know that my use of 'yes' should be 'use', but I think it reads nicer in this particular example) 04:01
japhb I ask because it seems like a windmill you tilt at with some regularity.
skids ShimmerFairy: figuring out where to hold the line between "use warnings" and what belongs some sort of Log:: module is the problem. 04:02
ShimmerFairy japhb: To be clear, I'm fine with P5 warnings, errors, and paranoid protections being on by default. I don't run into those warnings/errors often, admittedly, but it is a little LTA that stuff causes noisy warnings, or is paranoid-ly disallowed just because it's P5 syntax even though it'd make sense here, can't be turned off yet.
m: say qw//.perl 04:03
GLRelia rakudo-moar 7f6f85: OUTPUT«()␤»
camelia rakudo-moar 815fff: OUTPUT«()␤»
ShimmerFairy m: say <>.perl
GLRelia rakudo-moar 7f6f85: OUTPUT«5===SORRY!5=== Error while compiling /tmp/KZTDCaHL1R␤Unsupported use of <>; in Perl 6 please use lines() to read input, ('') to represent a null string or () to represent an empty list␤at /tmp/KZTDCaHL1R:1␤------> 3say <7⏏5>.perl␤»
camelia rakudo-moar 815fff: OUTPUT«5===SORRY!5=== Error while compiling /tmp/9ohlp4HVM9␤Unsupported use of <>; in Perl 6 please use lines() to read input, ('') to represent a null string or () to represent an empty list␤at /tmp/9ohlp4HVM9:1␤------> 3say <7⏏5>.perl␤»
lizmat once we get async stuff sufficiently stable, I would like to see warnings issued on a supply 04:04
ShimmerFairy ^ simple example. I think it's pretty clear that the <> should be eqv. to qw[] (i.e. an empty list), but you can't do it. I'm fine with dieing on it by default, but some kind of way to disable it would be nice
lizmat: I was thinking, maybe we don't want to call it warnings (except for 'warn' keywords used in P6), but worries/sorrows/panicks(?) for the compiler-related pragmas. 04:05
lizmat perhaps.... in any case, for production you would like to have warnings accumulated for a request / or a run 04:06
04:06 skids left
lizmat and issued somewhere else then in a log, presumably 04:06
ShimmerFairy lizmat: yeah, I think some kind of concurrency attached to warnings and/or errors would be nice. Would be nice to provide something more featureful than 2>my.log for putting warnings elsewhere, for instance :) 04:07
lizmat indeed, like deprecation warnings are handled now
ShimmerFairy I also think that enabling pragmas should use 'yes' as a keyword instead of 'use', since (to my P6 eyes), pragmas aren't like modules at all. Unless perhaps you are still supposed to be able to write your pragmas, like I heard you can in P5. 04:08
but that's mostly a "would be nice" kind of thing for me :) 04:09
lizmat well, I would be in favour of "yes" for pragma's
04:10 khw left
lizmat as the "no" functionality of *modules* from P5 won't ever work in P6 04:10
because the import happens at compile time already
and cannot be undone, afaik
ShimmerFairy it also reads better for what pragmas do, I think: no warnings; ... { yes warnings :P5; ... }
oh, there's a "no" usage for modules there? huh.
lizmat not in P6, I don't think 04:11
ShimmerFairy I know, I meant in P5. Sorry for not clarifying :)
lizmat calling the "unimport" methods on a class...not sure what that would mean in P6 context
ShimmerFairy looking at the breakdown of use in S11, I'm not sure which part is the "import" equivalent, and thus would need to be reversed 04:14
04:15 Loren_ joined
ShimmerFairy lizmat: if we even needed an opposite to 'use', I'd be tempted to say it should be called 'disuse' or some other verb more indicative of what it means (and then disuse -> unimport + needn't , hypothetically) 04:16
lizmat somehow I feel this discussion has happened before... so maybe we should wait until TimToady chimes in (if he has an opinion about this, of course) 04:17
ShimmerFairy lizmat: I certainly mentioned 'yes' as a possible alternate keyword before, but I don't think it led to a discussion. Not sure if it's been discussed otherwise :) 04:18
lizmat m: say [<a b c>].perl # fine! 04:19
GLRelia rakudo-moar 7f6f85: OUTPUT«["a", "b", "c"]␤»
camelia rakudo-moar 815fff: OUTPUT«["a", "b", "c"]␤»
lizmat m: say [<a b c>,42].perl # how do I get the <a b c> to flatten ???
camelia rakudo-moar 815fff: OUTPUT«["a", "b", "c", 42]␤»
GLRelia rakudo-moar 7f6f85: OUTPUT«[$("a", "b", "c"), 42]␤»
ShimmerFairy lizmat: looking at perldoc, "A pragma is a module which influences some aspect of the compile time or run time behaviour of Perl", I immediately thought "we can do that with slangs and macros from modules, we don't need pragmas the way P5 calls 'em" 04:20
m: say [<a b c>.Slip,42].perl
GLRelia rakudo-moar 7f6f85: OUTPUT«["a", "b", "c", 42]␤»
camelia rakudo-moar 815fff: OUTPUT«Method 'Slip' not found for invocant of class 'Parcel'␤ in block <unit> at /tmp/GPXjGDXIRU:1␤␤»
lizmat ShimmerFairy++ # it had Slipped my mind
ShimmerFairy it needs to be a Slip in order to "slip" into the list :)
lizmat wonder if we could make a prefix = act as a slip 04:23
ShimmerFairy lizmat: my initial guess is that, if we have user-made pragmas in P6, they would be based on slangs, and would not involve import/unimport. And I still say a keyword separation between modules and pragmas ('use' vs. 'yes'/'no') would be helpful :)
lizmat I agree....
moritz \o 04:24
lizmat moritz o/ 04:25
ShimmerFairy The only place where I wouldn't want the 'yes' keyword is 'use nqp;' , since I imagine an 'nqp' module in that case, which rakudo happens to provide integrated for free.
o/
lizmat yes MONKEY-TYPING
ShimmerFairy (but if that's not the intended view of 'use nqp', then nevermind :P)
lizmat well, that's not what it's doing, it's just allowing nqp:: in userland code
so "yes nqp" would make sense to me 04:26
04:26 xinming left, xinming joined
lizmat m: use nqp; nqp::say("foo"); no nqp; nqp::print("bar") 04:26
GLRelia rakudo-moar 7f6f85: OUTPUT«===============================================================================␤The use of nqp::operations has been deprecated for non-CORE code. Please␤change your code to not use these non-portable functions. If you really want␤to keep using nqp:…»
camelia rakudo-moar 815fff: OUTPUT«===============================================================================␤The use of nqp::operations has been deprecated for non-CORE code. Please␤change your code to not use these non-portable functions. If you really want␤to keep using nqp:…»
ShimmerFairy lizmat: in my imagination non-rakudo Perl6s could theoretically want to provide an nqp module for 'use nqp'. Though then again it could just as easily support the pragma form too.
lizmat m: use nqp; nqp::say("foo") 04:27
GLRelia rakudo-moar 7f6f85: OUTPUT«foo␤»
camelia rakudo-moar 815fff: OUTPUT«foo␤»
lizmat m: my $x = 42; my $y = 666; ($x,$y) = ($y,$x); dd $x, $y # this is known to be an issue, right ? 04:28
GLRelia rakudo-moar 7f6f85: OUTPUT«$x = 666␤$y = 666␤»
camelia rakudo-moar 815fff: OUTPUT«$x = 666␤$y = 42␤»
ShimmerFairy I remember that being provided as a simple example of something a few days back, but not sure 04:29
moritz m: say List.new.eager.^name
GLRelia rakudo-moar 7f6f85: OUTPUT«Seq␤»
camelia rakudo-moar 815fff: OUTPUT«List␤»
ShimmerFairy I remember that being provided as a simple example of something a few days back, but not sure 04:32
woops :P
moritz lizmat: I know it to be an issue, because I saw the test failing :-) 04:34
04:34 shinobi-cl joined
lizmat I seem to recall jnthn finding out STORE had to be 2-pass because of this 04:34
but maybe he just didn't do that yet... or is waiting to put in the compile time magic to only do 2-pass if really needed 04:35
m: (1,2,3).map({ $_ xx 3 }).perl # not, not saying anything, just .perling 04:36
GLRelia rakudo-moar 7f6f85: OUTPUT«This Seq has already been iterated, and its values consumed␤ in block <unit> at /tmp/yRtSIYCmBD:1␤␤»
camelia ( no output )
lizmat m: say (1,2,3).map({ $_ xx 3 }) # now saying it
GLRelia rakudo-moar 7f6f85: OUTPUT«This Seq has already been iterated, and its values consumed␤ in block <unit> at /tmp/uz9LDUaJff:1␤␤»
camelia rakudo-moar 815fff: OUTPUT«1 1 1 2 2 2 3 3 3␤»
lizmat m: (1,2,3).map({ $_ if $_ > 5 }).perl.say # glad to see this still sorta works 04:38
GLRelia rakudo-moar 7f6f85: OUTPUT«().iterator␤»
camelia rakudo-moar 815fff: OUTPUT«()␤»
lizmat m: (1,2,3).map({ next if $_ > 5; $_ }).perl.say # glad to see this still sorta works 04:39
GLRelia rakudo-moar 7f6f85: OUTPUT«(1, 2, 3).iterator␤»
camelia rakudo-moar 815fff: OUTPUT«(1, 2, 3)␤»
lizmat m: (1,2,3).map({ next if $_ > 5; $_ }).perl.say # so we don't need to use next
GLRelia rakudo-moar 7f6f85: OUTPUT«(1, 2, 3).iterator␤»
camelia rakudo-moar 815fff: OUTPUT«(1, 2, 3)␤»
lizmat m: (1,2,3).map({ next if $_ <= 5; $_ }).perl.say # what I actually meant
GLRelia rakudo-moar 7f6f85: OUTPUT«().iterator␤»
camelia rakudo-moar 815fff: OUTPUT«()␤»
dalek ast/glr: fc4fb81 | lizmat++ | integration/advent2011-day23.t:
Fix a test by slipping it
 04:41
lizmat m: <a b c>[0].say 04:45
GLRelia rakudo-moar 7f6f85: OUTPUT«a␤»
camelia rakudo-moar 815fff: OUTPUT«a␤»
04:45 jkva joined
lizmat m: <a b c>[0] = 42 04:45
GLRelia rakudo-moar 7f6f85: OUTPUT«Cannot modify an immutable Str␤ in block <unit> at /tmp/Uk0AqENVRf:1␤␤»
camelia rakudo-moar 815fff: OUTPUT«Cannot modify an immutable Str␤ in block <unit> at /tmp/yDP8d2YQ0D:1␤␤»
lizmat m: say <a b c> === <a b c> 04:46
GLRelia rakudo-moar 7f6f85: OUTPUT«False␤»
camelia rakudo-moar 815fff: OUTPUT«True␤»
lizmat I would posit that Lists generated with <a b c> should actually be a subclass of List that would be a value type
the immutability is already handled at the nqp level 04:47
ShimmerFairy considering you can't interpolate anything mutable into a qw[] (afaik), that sounds fair to me. 04:48
04:49 jkva left
dalek kudo/glr: a1c19d8 | moritz++ | src/core/Range.pm:
Implement a basic Range.elems

special-cases infinite lists, and optimizes for the Int..Int case		 04:53
lizmat m: my $a = 42; say <$a b c> # doesn't work
GLRelia rakudo-moar 7f6f85: OUTPUT«$a b c␤»
camelia rakudo-moar 815fff: OUTPUT«$a b c␤»
moritz m: my $a = 42; <<$a b c>>[0] = 23; say $a 04:54
GLRelia rakudo-moar 7f6f85: OUTPUT«Cannot modify an immutable Str␤ in block <unit> at /tmp/ptuMLMhiC7:1␤␤»
camelia rakudo-moar 815fff: OUTPUT«Cannot modify an immutable Str␤ in block <unit> at /tmp/D17TEnonFk:1␤␤»
lizmat m: (1..Inf).max.WHAT.say
GLRelia rakudo-moar 7f6f85: OUTPUT«(Num)␤»
camelia rakudo-moar 815fff: OUTPUT«(Num)␤»
lizmat m: (1..Inf).max.say 04:55
GLRelia rakudo-moar 7f6f85: OUTPUT«Inf␤»
camelia rakudo-moar 815fff: OUTPUT«Inf␤»
lizmat m: (1..*).max.say
GLRelia rakudo-moar 7f6f85: OUTPUT«Inf␤»
camelia rakudo-moar 815fff: OUTPUT«Inf␤»
lizmat moritz: * is not stored in $!min or $!max
it's either -Inf or Inf
moritz: so I think the first 2 checks are unnecessary 04:56
04:56 rangerprice left
moritz lizmat: ok; there's another check for nqp::istype($!max, Whatever) in Range.pm; I'll kill that too 04:58
04:58 mr-foobar left
lizmat :-) 04:58
05:00 cgfbee joined 05:02 cognominal left
dalek kudo/glr: 45c62e2 | moritz++ | src/core/Range.pm:
Remove redundant Whatever checks for Range endpoints, lizmat++
 05:05
lizmat m: my $a = (101..104); say 1 + $a.max - $a.min - $a.excludes-min - $a.excludes-max # moritz 05:08
GLRelia rakudo-moar a1c19d: OUTPUT«4␤»
camelia rakudo-moar 815fff: OUTPUT«4␤»
dalek ecs: 1d9fd64 | lizmat++ | S22-package-format.pod:
Mention CUR.uninstall
 05:15
ecs: b4d76e3 | lizmat++ | S (2 files):
Merge branch 'master' of github.com/perl6/specs
05:18 lizmat left
ugexe typo my $removed = $repo.install( $dist ); 05:20
install also takes :$dist... if its supposed to be that 05:21
05:23 lizmat joined 05:26 lizmat_ joined 05:27 lizmat left 05:28 lizmat joined 05:29 lizmat_ left
dalek ecs: e2a4087 | lizmat++ | S22-package-format.pod:
Fix type, ugexe++
 05:30
lizmat ugexe: re :$dist, I don't think the current impl is up to spec 05:31
hope to have this resolved after the SPW
05:34 KCL left 05:39 xinming left
dalek ast/glr: ca092df | lizmat++ | integration/advent2012-day20.t:
Fix a test by slipping and itemizing
 05:40
05:41 xinming joined
dalek ast/glr: 9320d1d | lizmat++ | integration/advent2012-day20.t:
Fix another test by slipping and itemizing
 05:43
05:45 xinming left 05:46 xinming joined 05:50 jkva joined 05:53 vendethiel joined 05:54 vendethiel left
masak morning, #perl6 05:57
moritz good morning, masak 05:59
dalek ast/glr: f8c114f | moritz++ | S12-methods/defer-call.t:
Add explicit flat() to defer-call.t
lizmat m: Set.grep(Set) # do we expect this to work ? 06:00
GLRelia rakudo-moar 45c62e: OUTPUT«Cannot look up attributes in a type object␤ in block <unit> at /tmp/vmKoBokcv0:1␤␤»
camelia ( no output )
lizmat m: Set.grep(Set).say
GLRelia rakudo-moar 45c62e: OUTPUT«Cannot look up attributes in a type object␤ in block <unit> at /tmp/BoZbFL3YQR:1␤␤»
camelia rakudo-moar 815fff: OUTPUT«(Set)␤»
06:00 rurban joined
lizmat m: set().grep(Set).say 06:00
GLRelia rakudo-moar 45c62e: OUTPUT«␤»
camelia rakudo-moar 815fff: OUTPUT«␤»
lizmat m: set(1,2,3).grep(Set).say
GLRelia rakudo-moar 45c62e: OUTPUT«␤»
camelia rakudo-moar 815fff: OUTPUT«␤»
moritz S32-list/map.t expects thing.map(*) to be a no-op 06:01
why? is that specced? Is it useful?
ShimmerFairy I can't think of a case where you want to do thing.map($a) and be able to assign $a a Whatever to make the .map do nothing 06:02
moritz but why call .map in the first place if you don't want to even potentially transform anything?
06:03 jkva left
moritz ah well, maybe it doesn't hurt to have a neutral element 06:03
lizmat moritz: it was intended to create an infinite list afaicr
ShimmerFairy moritz: exactly :) I don't see why you'd do a literal .map(*) , so I can only see thing.map($a) where $a = Whatever.new
lizmat I think it can go actually now 06:04
06:04 aborazmeh left
ShimmerFairy and I don't see why you wouldn't have another indicator beforehand, like if $want-transform { ... } or even @a.map($_) with $transform-func 06:04
06:06 jkva joined
dalek ast/glr: 2a492d2 | lizmat++ | integration/advent2012-day13.t:
Fix 2 tests by Slipping
 06:07
ast/glr: 6c6edcc | lizmat++ | integration/advent2012-day13.t:
DeTAB and whitespace alignment

No functional change
ast/glr: 8d5f2a4 | moritz++ | S32-list/map.t:
Remove .map(*) tests

  consensus on #perl6 was that it is not really needed		 06:08
masak I could maybe see .map($tfn) being useful, and then $tfn is sometimes *
moritz though {$_} would do too, no?
masak but frankly, if I did something like that, I'd do .map(&tfn), and then have &tfn = sub id { $^x }; 06:09
moritz: yes, of course. but {$_} is longer than *
moritz: I think the design "wants" to find and support all the cases where * means {$_}
even though * is more general than that, and can sometimes mean Inf, etc 06:10
moritz let's see how much of the ecosystem breaks when .map(*) doesn't work anymore
masak :)
moritz and if the fallout is significant, re-add it
06:10 freeze joined
moritz (it's a one-liner) 06:10
I posit that "somebody might find it useful" isn't a strong enough reason to keep a feature anymore
06:12 diana_olhovik joined, jkva left
ShimmerFairy masak: {$_} may be longer, but not by much, and it more clearly says "identity function" :) 06:15
06:18 freeze left, domidumont joined 06:19 freeze joined
dalek kudo/glr: 6b907ab | lizmat++ | src/core/ (2 files):
Add some signatures that we need in GLR
 06:20
lizmat this makes integration/advent2012-day13.t at lest pas now
*least
06:22 domidumont left 06:25 domidumont joined
lizmat m: say *.map({42.rand}) 06:25
GLRelia rakudo-moar 45c62e: OUTPUT«WhateverCode.new␤»
camelia rakudo-moar 815fff: OUTPUT«WhateverCode.new␤»
masak my argument wasn't "somebody might find it useful". 06:26
lizmat so not a way to create an infinite list of random numbers
masak but I have noticed that people reach for * meaning {$_} now and then because they expect it to work due to consistency.
lizmat m: my @a = *.map({42.rand}); say @a
camelia rakudo-moar 815fff: OUTPUT«WhateverCode.new␤»
GLRelia rakudo-moar 45c62e: OUTPUT«WhateverCode.new␤»
masak like, they are likely to go from *-1 or */2 to just *
m: my @a = 1, 2, 3; say @a[*-1]; say @a[*] 06:27
GLRelia rakudo-moar 6b907a: OUTPUT«3␤1 2 3␤»
camelia rakudo-moar 815fff: OUTPUT«3␤1 2 3␤»
masak ...which isn't always a reasonable assumption :)
anyway, I'm fine with removing support for .map(*)
lizmat Files=1036, Tests=41628, 200 wallclock secs (11.02 usr 3.28 sys + 1195.67 cusr 90.63 csys = 1300.60 CPU)
masak I didn't even know we had it :) 06:28
lizmat I think we're seeing the efficiency improvements of the GLR starting to shine through in the spectest wallclock and CPU usage 06:29
ShimmerFairy can it be seen in CORE compilation yet?
lizmat not really, not much P6 lazy listing going on while compiling core I don't think 06:31
06:32 espadrine joined
dalek kudo/glr: 46290dc | lizmat++ | src/core/Mu.pm:
Add .munch canary for now
 06:38
lizmat advent2010-day11.t was testing with it
masak we can't do heredocs in src/core ? 06:45
lizmat well, not sure anymore: they didn't use to work in core at one point 06:47
TimToady hasn't someone been working with electron here? 06:48
lizmat yes, but I can't find it in the ecosystem :-( 06:49
ShimmerFairy yes, azawawi IIRC
lizmat github.com/azawawi/perl6-electron 06:50
06:51 Ven joined 06:52 amurf joined
lizmat for ^9 {take <. X>[@i=map {%r{@i[($_-1)%19,$_,($_+1)%19].join}},^19].join}; # perl 6 line noise 06:54
and something's wrong in there... :-( 06:55
lizmat goes to another test file
ShimmerFairy first thing I notice is that $_ isn't being %19'd in the middle term 06:56
06:56 lizmat left, amurf left
masak lizmat: I knew it! Perl 6 is just as unmaintainable as Perl 5 -- this one line you pasted proves it. :P 06:58
masak .oO( "is observation bias common?" -- "yes! I see it everywhere!" ) 06:59
07:02 cognominal joined 07:06 shinobi-cl left 07:08 domidumont left, Ven left 07:16 darutoko joined 07:22 zakharyas joined 07:28 Possum left 07:37 davercc`` left 07:47 dg_subrata joined
dg_subrata In our project log rotating is done via perl script. All cout and cerr prints of a C++ server are piped to a perl script which then rotate the log. But this is creating some problem. Most of the time logs are not coming instantly in the log file. Seems perl is doing some amount of buffering. How can I overcome this issue. 07:47
07:47 Ven joined 07:49 telex left, notch left 07:50 cognominal left, telex joined
nine dg_subrata: man perlvar, look for autoflush. Also this is #perl6, you're probably looking for #perl :) 07:51
Woah, we're down to 177/1047 spec test files failing :) 07:52
.tell lizmat re commit 6b907ab9540de63941959252b3880fc6f67836c7, I'd be interested in _why_ we need those signatures now? 07:53
yoleaux nine: I'll pass your message to lizmat.
07:53 leont joined 07:55 Ven left
dalek kudo/glr: 979d2d4 | (Stefan Seifert)++ | src/core/Hash.pm:
Fix Hash.perl creating code that throws an error when EVALing

  .perl on an empty, itemized hash generated ${} which throws an error about
  ${} no longer being the correct syntax and using $() instead.
  {}.item means the same and is EVALable		 07:56
07:57 Ven joined
leont is still looking for a roommate for YAPC::EU, if interested please mail me at leont@cpan 08:03
nine m: say (<a b c>).perl; 08:06
GLRelia rakudo-moar 979d2d: OUTPUT«("a", "b", "c")␤»
camelia rakudo-moar 815fff: OUTPUT«("a", "b", "c")␤»
nine m: say (42, <a b c>).perl;
GLRelia rakudo-moar 979d2d: OUTPUT«(42, ("a", "b", "c"))␤»
camelia rakudo-moar 815fff: OUTPUT«(42, ("a", "b", "c"))␤»
nine m: my @a = (42, <a b c>); for @a -> $o { say $o.perl; } 08:07
GLRelia rakudo-moar 979d2d: OUTPUT«42␤$("a", "b", "c")␤»
camelia rakudo-moar 815fff: OUTPUT«42␤"a"␤"b"␤"c"␤»
nine Ah, another decade old bug in a spec test uncovered by GLR!
dalek ast/glr: 14ba91b | (Stefan Seifert)++ | S02-names-vars/perl.t:
Update S02-names-vars/perl.t to this decade

We don't have references anymore in Perl 6. Test captures instead of non-existing scalar refs. Fixes the deprecation warnings.		 08:11
ast/glr: a1a1468 | (Stefan Seifert)++ | S02-names-vars/perl.t:
Fix wrong test count in S02-names-vars/perl.t

The test count has been wrong since forever since the <a b c> got flattened and the list never tested. Instead we tested three single character strings. Now with the sane flattening semantics, we actually test test the list and thus run 4 fewer tests. Verified by manual test count.
FROGGS Guten Morgen 08:12
.tell AlexDaniel the qx//|run|shell issue is not a very big one on my list btw... there are more important issues we need to address 08:14
yoleaux FROGGS: I'll pass your message to AlexDaniel.
ShimmerFairy FROGGS: did you see my qwx// as a quoting version of 'run' suggestion the other day? 08:21
08:22 Ven left
masak morning, FROGGS 08:23
08:23 Ven joined
FROGGS ShimmerFairy: no, I didn't 08:24
hi masak
ShimmerFairy: why qWx ooc?
ShimmerFairy FROGGS: basically, if we really _need_ a shorter version of run for Huffman or something, qwx and qqwx would be my suggestions for run
FROGGS and how does such a call look like? 08:25
DrForr That smells like cdaddr...
ShimmerFairy FROGGS: because run is supplied a list of arguments, and one of the examples given in the complaint was run(«echo stuff»), which only goes to support the 'quotewords' thinking :)
08:25 cwDYKARN joined
ShimmerFairy FROGGS: basically, in my mind, qx/qqx is to shell like qwx/qqwx is to run 08:26
(though I'm still of the opinion that there's nothing that needs to be changed in the language, fwiw)
FROGGS hmmm
08:26 cognominal joined
FROGGS brb 08:27
08:27 FROGGS left
ShimmerFairy Waitaminute 08:27
m: my $b = 3; say «1 $b»
GLRelia rakudo-moar 979d2d: OUTPUT«13␤»
camelia rakudo-moar 815fff: OUTPUT«13␤»
ShimmerFairy m: my $b = 3; say qww/1 $b/
GLRelia rakudo-moar 979d2d: OUTPUT«1$b␤»
camelia rakudo-moar 815fff: OUTPUT«1$b␤»
ShimmerFairy m: my $b = 3; say qqw/1 $b/
GLRelia rakudo-moar 979d2d: OUTPUT«1 3␤»
camelia rakudo-moar 815fff: OUTPUT«1 3␤»
ShimmerFairy ok, so it is qqw :)
dalek ast/glr: 7a9e0c3 | (Stefan Seifert)++ | S02-names-vars/perl.t:
Fix comparison of a Seq with a list in S02-names-vars/perl.t
 08:28
nine And another file passing :)
ShimmerFairy or not, I didn't notice the space in qqw
08:29 FROGGS joined
ShimmerFairy S02 doesn't list a name for «», like <> has with qw// O_o (only says that «» is eqv. to qq:ww:v/.../) 08:30
m: my $b = 3; say qqww/1 $b/ 08:31
GLRelia rakudo-moar 979d2d: OUTPUT«13␤»
camelia rakudo-moar 815fff: OUTPUT«13␤»
ShimmerFairy ah, so I guess technically it should be qx//, qqx//, qwx//, and qqwwx// :)
FROGGS quotewords style parsing occurred to me as well... but I'd probably favour qxs// and qx// over qwx 08:32
08:33 RabidGravy joined
FROGGS where qxs invokes the shell and is therefore one char longer 08:33
I think we should experiment with this idea...
masak is qww a new thing?
FROGGS qx// would then default to qx:out// perhaps...
ShimmerFairy masak: no, apparently you can remove the colon with a short-form adverb 08:35
nine m: my $f = ("f fo foo" ~~ m:nth(0)/fo+/)
GLRelia rakudo-moar 979d2d: OUTPUT«Attempt to retrieve before :1st match -- :nth(0)␤ in block <unit> at /tmp/YwVWWiEo9p:1␤␤Actually thrown at:␤ in block <unit> at /tmp/YwVWWiEo9p:1␤␤»
camelia ( no output )
ShimmerFairy m: say Qb"Hello\n$World"
GLRelia rakudo-moar 979d2d: OUTPUT«Hello␤$World␤»
camelia rakudo-moar 815fff: OUTPUT«Hello␤$World␤»
nine Why isn't this failing on nom?
m: my $f = ("f fo foo" ~~ m:nth(0)/fo+/); say $f.WHAT;
camelia rakudo-moar 815fff: OUTPUT«(Bool)␤»
GLRelia rakudo-moar 979d2d: OUTPUT«Attempt to retrieve before :1st match -- :nth(0)␤ in block <unit> at /tmp/MkDMSE_QrY:1␤␤Actually thrown at:␤ in block <unit> at /tmp/MkDMSE_QrY:1␤␤»
nine m: my $f = ("f fo foo" ~~ m:nth(0)/fo+/); say $f; 08:36
GLRelia rakudo-moar 979d2d: OUTPUT«Attempt to retrieve before :1st match -- :nth(0)␤ in block <unit> at /tmp/EMUo5So3N8:1␤␤Actually thrown at:␤ in block <unit> at /tmp/EMUo5So3N8:1␤␤»
camelia rakudo-moar 815fff: OUTPUT«False␤»
ShimmerFairy FROGGS: I'd prefer not clobbering the qx// and qqx// meanings (of being like shell() ), since it's of little value and so close to the RC and christmas. 08:37
FROGGS wow, only 175 test files left 08:38
ShimmerFairy: we could still experiment with it in a branch, is all 08:39
I'm not saying it is urgent... :o) 08:40
ShimmerFairy FROGGS: like I said, I think it's a non-issue in the first place, at least as far as language design is concerned :) 08:41
FROGGS yeah, I tend to agree 08:42
m: say 'xxy'.index( 'y', -1e35 )
GLRelia rakudo-moar 979d2d: OUTPUT«2␤»
camelia rakudo-moar 815fff: OUTPUT«Nil␤»
FROGGS m: say 'xxy'.index( 'y', -1e34 )
GLRelia rakudo-moar 979d2d: OUTPUT«Nil␤»
camelia rakudo-moar 815fff: OUTPUT«Nil␤»
FROGGS m: say 'xxy'.index( 'y', -1e36 ) 08:43
GLRelia rakudo-moar 979d2d: OUTPUT«2␤»
camelia rakudo-moar 815fff: OUTPUT«Nil␤»
08:44 domidumont joined 08:45 kanl joined
kanl dg_subrata: if your project runs on linux/unix, djb's daemontools + multilog may be preferable to your perl script solution. check out cr.yp.to if you're interested. 08:46
dg_subrata: daemontools is basically djb's replacement for xinetd. while your c++ server is guarded by daemontools, its stdour/stderr is hooked to multilog and rotated according to configuartion (by size, number of logs to keep etc..) 08:49
nine kanl: aren't daemontools obsoleted by systemd now? 08:50
ShimmerFairy only if you use systemd, I'd imagine :) 08:51
kanl also true, i have a bunch of legacy systems..
for compatibility i just deploy daemontools, which works just fine. 08:52
ShimmerFairy I don't use systemd, but only because there's no incentive to actually doing the switching over for me. 08:53
RabidGravy coo do people still use djb-ware? real blast from the past there.
dalek kudo/glr: c292e13 | moritz++ | src/core/operators.pm:
Fix infix:<does> with several roles at once

Makes S14-roles/mixin.t pass		 08:54
08:54 luiz_lha joined 08:55 luiz_lha is now known as Guest2181
kanl RabidGravy: we have about 20K servers running centos 5.4 in production :) 08:55
FROGGS m: use nqp; say nqp::unbox_i(-1e35) 08:56
GLRelia rakudo-moar 979d2d: OUTPUT«(signal SEGV)»
camelia rakudo-moar 815fff: OUTPUT«This type cannot unbox to a native integer␤ in block <unit> at /tmp/QvhU7ZhEvH:1␤␤»
FROGGS ups
RabidGravy that'll do it to you every time :) 08:57
moritz m: my $latin-chars = [~] chr(0)..chr(0xFF); say $latin-chars.comb(/<space>/)>>.ord.join(",")
GLRelia rakudo-moar c292e1: OUTPUT«9,10,11,12,13,32,133,160␤»
camelia rakudo-moar 815fff: OUTPUT«9,10,11,12,13,32,133,160␤»
dalek ast/glr: 0893808 | moritz++ | S05-mass/charsets.t:
Enforce range interpolation
 08:58
FROGGS sad, locally I don't get a segfault
m: use nqp; say nqp::unbox_i(-1e35) 08:59
GLRelia rakudo-moar c292e1: OUTPUT«This type cannot unbox to a native integer␤ in block <unit> at /tmp/OVR8FJtZPA:1␤␤»
camelia rakudo-moar 815fff: OUTPUT«This type cannot unbox to a native integer␤ in block <unit> at /tmp/8iOTB0nXUr:1␤␤»
FROGGS ahh :/
that was either the commit before or during rebuild
El_Che kanl: I don't know what's more impressive. Having 20k server or still running centos 5.4 ;) 09:00
dalek ast/glr: e6ab8ae | moritz++ | S05-mass/properties-general.t:
Enforce range interpolation
nine moritz: what would be the difference between "my \real-roles = eager @roles.map" and "my \real-roles := eager @roles.map"? 09:01
kanl El_Che: 20k is modest deployment scale for a search engine. and 5.4 is the stablest system if you rely on XFS .. 09:02
moritz nine: uhm, nothing; should probably be = in both cases
nine moritz: oh, interesting. I've mostly seen (and thus used) := for assignment to sigilless vars
El_Che On the other hand I used --/me puts his old white beard on-- to run a huge solaris 8 farm almost single-hadled (my collegues back then where just escaping the mainframe) :) 09:03
moritz nine: since sigilless vars can't be re-asssigned (or re-bound), and don't force a container, I don't think there's much practical difference anyway
El_Che perl5 helped me keep my sane state (it was before the configuration management time) :) 09:04
kanl: ddg?
nine moritz: that they don't have a container makes it more logical to me to only bind them. But probably the compiler is smart enough to just do the same on assignment :)
TEttinger kanl: yandex? 09:06
kanl El_Che,TEttinger: no, but i have friends that work there :) 09:07
dalek kudo/glr: 9f58110 | lizmat++ | src/core/Cool.pm:
Handle out-of-bounds pos in index/rindex better

Fixes #125784		 09:13
09:14 leont left 09:31 abraxxa joined 09:34 Ven left, espadrine left
JimmyZ :q 09:34
09:34 Guest2181 is now known as luiz_lha 09:36 pflanze joined
JimmyZ FROGGS: re 9f581101ad, we seems to already do the check in MoarVM 09:45
FROGGS JimmyZ: and there we throw probably?
JimmyZ I cant follow you .. 09:46
MoarVM returns -1 alreay 09:47
*already
FROGGS hmmm, I dont think so
m: use nqp; my int $i = nqp::index(nqp::unbox_s("abc"),nqp::unbox_s("c"),nqp::unbox_i((-1e35).Int)); say $i
GLRelia rakudo-moar 9f5811: OUTPUT«2␤»
camelia rakudo-moar 815fff: OUTPUT«2␤»
JimmyZ m: use nqp; my int $i = nqp::index(nqp::unbox_s("abc"),nqp::unbox_s("c"),nqp::unbox_i((-nqp::pow(2,65)).Int)); say $i 09:49
GLRelia rakudo-moar 9f5811: OUTPUT«===SORRY!===␤No registered operation handler for 'pow'␤»
camelia rakudo-moar 815fff: OUTPUT«===SORRY!===␤No registered operation handler for 'pow'␤»
JimmyZ m: use nqp; my int $i = nqp::index(nqp::unbox_s("abc"),nqp::unbox_s("c"),nqp::unbox_i((-nqp::pow_I(2,65)).Int)); say $i 09:50
GLRelia rakudo-moar 9f5811: OUTPUT«===SORRY!===␤Arg count 2 doesn't equal required operand count 5 for op 'pow_I'␤» 09:51
camelia rakudo-moar 815fff: OUTPUT«===SORRY!===␤Arg count 2 doesn't equal required operand count 5 for op 'pow_I'␤»
09:51 cwDYKARN_ joined 09:52 leont joined 09:53 espadrine joined, cwDYKARN_ left
RabidGravy m: class Foo { subset Format of uint16 where * < 3; }; my Foo::Format $a = 0 10:01
GLRelia rakudo-moar 9f5811: OUTPUT«Type check failed in assignment to '$a'; expected 'Format' but got 'Int'␤ in block <unit> at /tmp/kKcTG6AIJ7:1␤␤»
camelia rakudo-moar 815fff: OUTPUT«Type check failed in assignment to '$a'; expected 'Format' but got 'Int'␤ in block <unit> at /tmp/nQNlh4TUt8:1␤␤»
RabidGravy m: say uint16 ~~ Int 10:02
GLRelia rakudo-moar 9f5811: OUTPUT«True␤»
camelia rakudo-moar 815fff: OUTPUT«True␤»
10:02 xinming left
RabidGravy this confuses me 10:02
JimmyZ m: use nqp; say nqp::unbox_i(-1e35.Int); 10:03
GLRelia rakudo-moar 9f5811: OUTPUT«0␤»
10:03 cwDYKARN_ joined
camelia rakudo-moar 815fff: OUTPUT«0␤» 10:03
JimmyZ m: use nqp; say nqp::unbox_i(-1e34.Int);
GLRelia rakudo-moar 9f5811: OUTPUT«-3458764513820540928␤»
camelia rakudo-moar 815fff: OUTPUT«-3458764513820540928␤»
10:03 xinming joined 10:05 cwDYKARN_ left 10:07 rindolf joined 10:09 cwDYKARN_ joined
JimmyZ .tell jnthn looks like we have pow_i in MoarVM, but it never be used in nqp/rakudo 10:10
yoleaux JimmyZ: I'll pass your message to jnthn.
ShimmerFairy JimmyZ: not surprised about rakudo (tends to use _I bigint ops instead), but nqp not using it anywhere is interesting. 10:13
10:15 pmurias joined
JimmyZ well , since nqp is a compiler .. 10:16
pmurias JimmyZ: ? 10:21
nine I guess you don't need pow that often in a compiler ;) 10:22
10:24 leont left
ShimmerFairy Right now I'm working on getting $¢ working properly (because I found I'm typing $/.CURSOR a bit too much atm). Enabling it in nqp was scarily easy, but it's proving quite a bit harder in rakudo, at least outside of regex/token/rule decls :P 10:24
10:26 domidumont left 10:28 xfix joined 10:29 virtualsue joined, virtualsue left, amurf joined 10:30 TEttinger left
FROGGS ShimmerFairy: can't you just make it a term:sym<¢> and let the actions turn it into $/.CURSOR? 10:32
ShimmerFairy Well, $¢ is what's spec'd, and I can easily enable it in NQP and in token foo { } regexes. It's the inline ~~ // stuff in P6 that's acting weird. 10:33
oh, you mean in my own code :)
RabidGravy time for either more coffee, find my glasses or use a bigger font. I can barely tell the difference between $c and $¢
10:33 amurf left 10:34 Ven joined
ShimmerFairy FROGGS: I of course could (though defining a term:sym<> didn't occur to me), but 1) I don't know how that would conflict with the ¢ sigil, if that ever makes a miraculous comeback, and 2) might as well put in support for the spec'd thing if I'm going to do anything :) 10:34
FROGGS ShimmerFairy: it would not conflict with a sigil, because of LTM 10:36
10:42 Possum joined 10:50 zakharyas left
dalek kudo/glr: f9e6df2 | FROGGS++ | src/core/Str.pm:
fix Str.split and Str.match wrt GLR
 10:55
moritz m: map { 2 * $_ } 2..5 10:58
GLRelia rakudo-moar f9e6df: OUTPUT«5===SORRY!5=== Error while compiling /tmp/3rvpuZTUAg␤Missing comma after block argument to map␤at /tmp/3rvpuZTUAg:1␤------> 3map { 2 * $_ }7⏏5 2..5␤ expecting any of:␤ infix␤ infix stopper␤»
camelia rakudo-moar 815fff: OUTPUT«5===SORRY!5=== Error while compiling /tmp/S8XWjtIOt1␤Missing comma after block argument to map␤at /tmp/S8XWjtIOt1:1␤------> 3map { 2 * $_ }7⏏5 2..5␤ expecting any of:␤ infix␤ infix stopper␤»
moritz m: say map { 2 * $_ }, 2..5
GLRelia rakudo-moar f9e6df: OUTPUT«4 6 8 10␤»
camelia rakudo-moar 815fff: OUTPUT«4 6 8 10␤»
moritz m: say [+] 1, map { 2 * $_ }, 2..5
GLRelia rakudo-moar f9e6df: OUTPUT«5␤»
camelia rakudo-moar 815fff: OUTPUT«29␤»
nine m: say [+] flat 1, map { 2 * $_ }, 2..5 10:59
GLRelia rakudo-moar f9e6df: OUTPUT«29␤»
camelia rakudo-moar 815fff: OUTPUT«29␤»
nine I'd really love to see | as flattening operator 11:01
moritz or a separate operator for list concatenation
nine m: say [+] 1, | map { 2 * $_ }, 2..5
GLRelia rakudo-moar f9e6df: OUTPUT«29␤»
camelia rakudo-moar 815fff: OUTPUT«29␤»
dalek p: 9d35d8d | (Jimmy Zhuo)++ | src/vm/moar/QAST/QASTOperationsMAST.nqp:
map pow_i opcode
nine Which in this case it even is
moritz loves "! [rejected]" during git push; it means other folk were busy! 11:02
dalek kudo/glr: 8d70a3a | moritz++ | src/core/Temporal.pm:
Fix Datish.day-of-year
11:03 abraxxa left 11:04 zakharyas joined 11:12 dayangkun left
moritz TimToady: do we need List.tree post-GLR? the original intent (making inner lists not flatten) is the default now, and the stuffed-on extra functionality doesn't seem to fit the method name anymore 11:13
nine Does anyone have an idea why LoL had to go?
moritz: seems like we're investigating the same case :) 11:14
moritz never understood the point of LoL, except if it was to disable flattening of sublists
nine Ok for that we can just use List now
moritz nine: no, I was looking at S32-lists/tree.t, which predates implementation of LoL
nine But then what's the point of having the (1;2;3) syntax? 11:15
moritz no idea
maybe compact storage?
nine moritz: you probably mean S02-lists/tree.t and I was indeed investigating the same 11:16
moritz nine: ok; looking at reduce next 11:17
11:21 smls joined
nine I wonder what code would trigger Array.ASSIGN-POS 11:21
ShimmerFairy oh, another thing about choosing to implement $¢ instead of a local solution: I don't imagine the difference is that great, but I imagine $¢.MATCH.CURSOR is probably less optimal than $¢ :)
moritz nine: my @a = 42; @a[0] = 2 11:22
ShimmerFairy (since $/ is just $¢.MATCH, if I understand the existing code correctly)
nine moritz: how can that be? Array.ASSIGN-POS is commented out in GLR
moritz nine: there might be a fallback if ASSGIN-POS does not exist
smls there is 11:23
it uses AT-POS then
(which is expected to return an rw container)
moritz m: class A { method ASSIGN-POS($idx, \val) { say val } }; A.new[0] = 42
GLRelia rakudo-moar 8d70a3: OUTPUT«42␤»
camelia rakudo-moar 815fff: OUTPUT«42␤»
moritz ASSIGN-POS is both an implementation convenience and an optimization 11:24
nine ok
11:24 domidumont joined
nine Looks like ASSIGN-POS will be very much like AT-POS. I'll just go for it :) 11:25
smls documented at doc.perl6.org/language/subscripts#M...bscripting btw, though it does not yet document the multi-dim extension that jnthn was working on. 11:26
moritz m: my $a = [1, 2, 3]; my @b = $a; say @b.items 11:31
GLRelia rakudo-moar 8d70a3: OUTPUT«Method 'items' not found for invocant of class 'Array'␤ in block <unit> at /tmp/N62vXUR7fI:1␤␤»
camelia rakudo-moar 815fff: OUTPUT«Method 'items' not found for invocant of class 'Array'␤ in block <unit> at /tmp/wfLjvp10uK:1␤␤»
moritz m: my $a = [1, 2, 3]; my @b = $a; say @b.elems
GLRelia rakudo-moar 8d70a3: OUTPUT«1␤»
camelia rakudo-moar 815fff: OUTPUT«1␤»
11:31 Ven left 11:32 RabidGravy left, Ven joined 11:38 FROGGS_ joined 11:40 dayangkun joined 11:42 FROGGS left 11:43 rurban left 11:48 smls left, smls joined
rarara smls: 'multi-dim extension', are you planning fortran style arrays (many indices) in perl 6? 11:54
smls yeah, one index per dimension 11:55
like @a[1; 1; 1]
by default it will just be sugar for nested indexing, i.e. @a[1;1;1] would become @a[1][1][1]
*but* if the object supports it, it may handle all dimensions directly 11:56
and compact native arrays support that, for example
rarara ah that's amazing! So there could also be a compact Matrix object
nine exactly 11:57
rarara and maybe even some easy to use sparse matrix library
smls in fact I thing it already partially works
rarara: Yeah, it's been designed with PDL-like usecases in mind 11:58
dalek kudo/glr: 6a86a67 | (Stefan Seifert)++ | src/core/Array.pm:
Implement Array.ASSIGN-POS
 12:01
nine That was quite pain free :)
We're now at 169/1047 btw. 12:02
Ven nine++
12:06 rurban joined
arnsholt nine: 169 failing test files? 12:14
nine arnsholt: yes
12:14 dayangkun left 12:16 rindolf left 12:19 amurf joined
timotimo o/ 12:20
12:20 dg_subrata left
timotimo good news: after catapulting my thinkpad off a table, the only things broken are: a bit of plastic has exploded off of the side, and the plug of the power adapter is a tiny bit slanted now 12:20
nine Thinkpads++ 12:21
timotimo yeah. i opened it up and was amazed - not for the first time - at how well it's built
ShimmerFairy
.oO(bad news: there wasn't any downside to make this setup work right)
 12:22
timotimo ShimmerFairy: the bad news is that if i had had a macbook, i wouldn't have been able to pull it off of the table via its power cord
ShimmerFairy timotimo: true, though I suppose you could turn that around and say "Macbooks have flimsy plug connectors" :P 12:23
12:23 amurf left
timotimo i think that'd be dishonest 12:23
on the other hand, i'm pretty sure a macbook would have taken a bit more damage than my thinkpad 12:24
actually
i'm not sure at all
ShimmerFairy timotimo: it's Marketing Honest™, which is good enough in some circles :)
timotimo argh :)
ShimmerFairy timotimo: I can say that I got two old powerbooks from a teacher years ago, and the difference between the G3 and G4 laptops in terms of take-apart-ability was significant (and interesting) 12:26
timotimo i've heard many things are fastened via glue rather than screws or latches
but that's probably not for old powerbooks, just for the newer models? 12:27
ShimmerFairy probably
nine timotimo: that reminds me of the PQAH where the Apple magnetic power plug was quite flimsy and wouldn't connect right most of the time. 12:28
timotimo perl quality assurance hackathon?
nine timotimo: I rather have a sturdy laptop that survives a fall, whatever the reason.
timotimo: yes
ShimmerFairy The shiny one (G4) had early signs of the signature Apple Don't-Open-This design style, but the black G3 had it where the keyboard could easily be pulled out via two tabs on the top (there was a lock to prevent that, but amusingly it was broken :P)
timotimo mhm 12:29
timotimo remembers a horrible photograph of a macbook that had been bent out of shape to reveal the hard drive 12:30
with the flavor text "this is not how you replace a hard drive" or something
dalek kudo/glr: 6b3930e | moritz++ | src/core/ (2 files):
Restore some .reduce functionality
12:33 dnmfarrell joined
dnmfarrell Hi all. Is there a way to loop through a match objects sub-matches in the order they were match? The docs say .list() but it is empty for me github.com/dnmfarrell/Pod-Perl5/bl...TML.pm#L47 12:35
moritz dnmfarrell: .caps
timotimo .list probably only gives you positional submatches, not named ones 12:36
right?
moritz right
.caps gives you both, order by .from
*ordered
ShimmerFairy m: say "ABC" ~~ /<alpha>+/; for @($/) { say $_ } 12:37
GLRelia rakudo-moar 6b3930: OUTPUT«｢ABC｣␤ alpha => ｢A｣␤ alpha => ｢B｣␤ alpha => ｢C｣␤»
camelia rakudo-moar 815fff: OUTPUT«｢ABC｣␤ alpha => ｢A｣␤ alpha => ｢B｣␤ alpha => ｢C｣␤»
ShimmerFairy m: say "ABC" ~~ /(\w)+/; for @($/) { say $_ }
GLRelia rakudo-moar 6b3930: OUTPUT«｢ABC｣␤ 0 => ｢A｣␤ 0 => ｢B｣␤ 0 => ｢C｣␤｢A｣ ｢B｣ ｢C｣␤»
camelia rakudo-moar 815fff: OUTPUT«｢ABC｣␤ 0 => ｢A｣␤ 0 => ｢B｣␤ 0 => ｢C｣␤｢A｣ ｢B｣ ｢C｣␤»
dnmfarrell ahh thanks :)
ShimmerFairy seems to work OK
moritz m: say "ABC" ~~ /<alpha>+/; say .git for $/.caps 12:38
GLRelia rakudo-moar 6b3930: OUTPUT«｢ABC｣␤ alpha => ｢A｣␤ alpha => ｢B｣␤ alpha => ｢C｣␤Method 'git' not found for invocant of class 'Pair'␤ in block <unit> at /tmp/f_csbQvMlj:1␤␤»
camelia rakudo-moar 815fff: OUTPUT«｢ABC｣␤ alpha => ｢A｣␤ alpha => ｢B｣␤ alpha => ｢C｣␤Method 'git' not found for invocant of class 'Pair'␤ in block <unit> at /tmp/3HHomSGbSf:1␤␤»
moritz m: say "ABC" ~~ /<alpha>+/; say .Str for $/.caps
GLRelia rakudo-moar 6b3930: OUTPUT«｢ABC｣␤ alpha => ｢A｣␤ alpha => ｢B｣␤ alpha => ｢C｣␤alpha A␤alpha B␤alpha C␤»
camelia rakudo-moar 815fff: OUTPUT«｢ABC｣␤ alpha => ｢A｣␤ alpha => ｢B｣␤ alpha => ｢C｣␤alpha A␤alpha B␤alpha C␤»
moritz m: "ABC" ~~ /<alpha>+/; say .Str for $/.caps
GLRelia rakudo-moar 6b3930: OUTPUT«alpha A␤alpha B␤alpha C␤»
camelia rakudo-moar 815fff: OUTPUT«alpha A␤alpha B␤alpha C␤»
moritz m: "ABC" ~~ /<alpha>+/; say .value.Str for $/.caps
GLRelia rakudo-moar 6b3930: OUTPUT«A␤B␤C␤»
camelia rakudo-moar 815fff: OUTPUT«A␤B␤C␤»
12:39 pnu left, hobbs joined
dnmfarrell moritz: it works ! :D 12:40
12:40 rurban_ joined
dalek p: b6c791b | (Jimmy Zhuo)++ | src/vm/jvm/runtime/org/perl6/nqp/runtime/Ops.java:
add pow_i to jvm backend
 12:41
12:44 Ven left, rindolf joined
dalek p: ebfd308 | (Jimmy Zhuo)++ | src/vm/jvm/QAST/Compiler.nqp:
map pow_i opcode to jvm backend
 12:44
12:44 Ven joined 12:45 lizmat joined 12:48 FatalNIX joined, pnu joined
JimmyZ .tell jnthn ignore it, I make it being used now. 12:55
yoleaux JimmyZ: I'll pass your message to jnthn.
timotimo ignore what?
JimmyZ timotimo: pow_i
timotimo ah, ok
JimmyZ it'd be nice someone merge my pr and bump nqp version :) 12:56
masak jnthn: I saw your "Inf ~~ Int will never happen" in the backlog. I'd like to talk about that sometime. I remember vividly how TimToady (perhaps a year or so ago) provided a way forward on that. 12:58
jnthn: it wasn't so much an *exact* implementation plan as it was an assurance that it could be done. 12:59
jnthn: I remember it because it convinced me.
jnthn: and I was wondering whether you've seen it, and whether it convinced you.
13:03 skids joined
masak fwiw, I just had a MAIN sub where I wanted to write `Int $max = Inf`... 13:04
jnthn masak: I'm basically burned out with the topic and wish it'd go away.
yoleaux 20 Aug 2015 16:51Z <japhb> jnthn: I am seriously loving gist.github.com/anonymous/6607717a5d201a9acf82 ... I'm using it for language bragging rights with various friends. Can't wait to be using the finished API. :-)
10:10Z <JimmyZ> jnthn: looks like we have pow_i in MoarVM, but it never be used in nqp/rakudo
12:55Z <JimmyZ> jnthn: ignore it, I make it being used now.
masak jnthn: ok.
jnthn masak: I'm beyond the point of being interested in being convinced. 13:05
masak: If anything's going to happen, then it's SEP.
dalek kudo/glr: 55b3264 | (Stefan Seifert)++ | src/core/native_array.pm:
Implement native array iterators
masak sad to hear that, but that's an acceptable response.
jnthn (I won't get in the way of somebody else working on it, of course.)
nine Those were so simple, I wonder why noone has picked this LHF before :)
masak I'm mostly interested in us resolving it one way or another. 13:06
either eradicating the dream from the spec, or implementing the dream.
moritz masak: one problem is that whatever you do, you have to create a layer of indirection to prevent us from passing Inf to the underlying bigint lib (which doesn't support Inf)
masak aye. 13:07
guess there are some operations that should simply die, even post-Inf~~Int
but I think jnthn is right, that the most central problem is "what type?"
moritz down to 166 spectest file fail (before nine++'s patch) 13:08
masak if we want to support Inf for Int/Num/Str, for example, that suggests that the type must be `Int & Num & Str`
nine jnthn: I wasted several hours yesterday trying to make hllization of nqp::list bind the list as IterationBuffer to $!reified, since almost all list code is expecting that. Can you tell me why that's a stupid idea?
masak or is that `Int | Num | Str`? whatever makes Inf (and -Inf) assignable to each of those types. 13:09
jnthn nine: afaik it only cares that it is an IterationBuffer if the List has unreified parts
nine: And when we hllize things they're never lazy 13:10
moritz class InfOrMinusInf is Num is Int is Str { }
jnthn nine: So I figured it'd be no problem to bind an NQP array directly to $!reified
13:11 dnmfarrell left
jnthn nine: Does it turn out to be a problem somewhere? :) 13:11
skids The issue raised in PR#502 may bear on that matter, depending on the decision made there.
lizmat wonders whether she has messages
yoleaux 07:53Z <nine> lizmat: re commit 6b907ab9540de63941959252b3880fc6f67836c7, I'd be interested in _why_ we need those signatures now?
nine jnthn: I wanted to use FLATTENABLE-LIST there: github.com/rakudo/rakudo/blob/glr/...ps.pm#L488 which failed because in line 495 we then call nqp::elems on a List instead of a VMArray
lizmat nine: Set.grep(Set) was calling the Set.list, which had no restrictor on the object 13:12
ShimmerFairy masak: as I understand it, the problem is that Inf and NaN are literally just names for the IEEE values, so of course they'd only work with Num :)
lizmat this caused "cannot use attributes on a type object" error
adding the signature, caused it to be not selected but instead the generic .list
nine lizmat: ah, thanks
ShimmerFairy (and when you think about it like that, I'm tempted to say it shouldn't work on non-Num, since they're clearly Num values) 13:13
lizmat I'm not sure why that wasn't a problem pre-GLR
m: say Set.grep(Set)
GLRelia rakudo-moar 55b326: OUTPUT«␤»
camelia rakudo-moar 815fff: OUTPUT«(Set)␤»
jnthn nine: The trouble is that calling a method automatically does hllize on whatever it returns
nine lizmat: several things worked mysteriously pre-GLR
13:13 rmgk is now known as Guest26049, rmgk_ joined, Guest26049 left, rmgk_ is now known as rmgk
hoelzro good perl6, #morning! 13:13
lizmat m: say [Set].grep(Set)
GLRelia rakudo-moar 55b326: OUTPUT«(Set)␤»
camelia rakudo-moar 815fff: OUTPUT«(Set)␤»
jnthn nine: FLATTENABLE_LIST is only used for |@foo style things, and since the compiler emits the call it can avoid thta hllize 13:14
nine jnthn: that's what I figured. Hence I tried to hllize the nqp::list to an IterationBuffer before assigning to $!reified of the List object. I patched MoarVM to allow rebless on VMArray and nqp to allow is repr on a stub but then ran into a nightmare of debugging
jnthn eww 13:15
No, users should never normally see IterationBuffer
nqp::list should hllize to List
If you want the $!reified from List then you should just getattr it
masak ShimmerFairy: just because IEEE 754 defines Inf doesn't mean it has exclusive rights to it.
nine jnthn: it would. I just reblessed $!reified to IterationBuffer
jnthn nine: But why do you need to dothat?
masak ShimmerFairy: also there's no doubt that (a) there's a use case here, nor that (b) Inf makes sense as "extreme comparison values" for a lot of comparable types. even user-defined types could theoretically get in on the game. 13:16
ShimmerFairy masak: sure, I'm just saying that when you think of Inf as a name for the IEEE value (which it currently is), then of course it shouldn't work. :)
nine jnthn: so the List code can be sure it will be an IterationBuffer (it already assumes in countless places) regardless of where the List is coming from.
JimmyZ stupid questiond: re IterationEnd, is there a reason we can't s/IterationEnd/Nil/?
masak ShimmerFairy: well, it isn't only that, by spec.
jnthn JimmyZ: Yes
moritz jnthn: the problem is/was that $!refified of a normal List (contstructed via List.new) is an IterationBuffer, but, but hllize create a List where $!refied was an NQP-level array
jnthn moritz: I'm aware, but when I implemented List the ONLY places that relied on it being an IterationBuffer were code-paths where the List had a $!todo 13:17
And that's *never* true for hllize'd things.
nine So @a>>.say would work, but @a.^methods>>.say would fail
moritz ok
ShimmerFairy masak: my thinking is that Inf would have to be something like Nil or Empty, and I'm not sure if that's desired.
moritz jnthn: maybe that assumption was broken somewhere along the way 13:18
jnthn nine: If so, then >>.say is probably assuming the thing it gets is an IterationBuffer, not just any old VMArray
13:18 woolfy joined
jnthn moritz: Yes, I'm guessing so...I think I'd prefer to unbreak it :) 13:18
ShimmerFairy (and btw, I definitely don't think NaN has much (if any) utility beyond floating point. It is, after all, not a number in the first place ☺)
jnthn JimmyZ: Of note, Nil can actually exist in a List 'cus it does not vanish inside of them 13:19
moritz ShimmerFairy: NaN as an integer would serve mostly the same function as the Int type object
nine jnthn: yes, that was just me trying to be clever and use FLATTENABLE-LIST which looked like a perfect match for what I did
On the bright side: we're at 167/1047 failing spec test files :)
jnthn nine: Ah. Yeah, I'd probably not do that :)
JimmyZ jnthn: thanks :)
jnthn Wow...that's really nie progress :)
skids Well, wouldn't a .plan be able to add a $!todo to a List gotten via hllization?
jnthn *nice
13:19 rindolf left
ShimmerFairy moritz: exactly my thinking. we have plenty of not-numbers already, NaN is just useful for floating point because it's a real thing we can get out of floating-point. 13:20
jnthn skids: .plan is a method on Array, not List
skids Ah.
jnthn skids: List is immutable, you can't .plan
(That also ties quite strongly into my hllize assumption :))
skids Anyway, any inclination as to what to do about the Failure transparency issue?
jnthn skids: I need to look at it when I've got more brain 13:21
(My body is not doing at all well with the jet lag :()
skids :-) well, good luck crusing for brainnnz :-)
masak ShimmerFairy: agree on NaN not being useful outside of floating-point. 13:22
ShimmerFairy masak: of course, what we really need is role HyperReal does Real { ... } :P
moritz for some values of "really"
masak ShimmerFairy: no, not really.
anyway, I think TimToady's helpful handwave was also something like what you're saying, ShimmerFairy. 13:24
that Inf was a kind of "bottom type" for certain comparable types.
ShimmerFairy the HyperReal was a joke, btw
hoelzro finally understands the difference between "das gleiche" and "das selbe" due to 'eqv' and '===' 13:25
nine jnthn: if you find any time at all for some glr hacking it would be great if you could have a look at t/spec/S02-types/flattening.t. Would be enough if you review the tests, then we can fix the implementation. I'm just still too unsure about the wanted semantics :/
FROGGS_ 167 test files left...
smls ShimmerFairy: 'Surreal' would be an even better name than "HyperReal'... :P 13:26
FROGGS_ (on 2015.07.1-399-g6b3930e at least)
ShimmerFairy smls: not if you just want to support infinity and infinitesimal. Counting nesting would be horrendous :P
13:26 FROGGS_ is now known as FROGGS
jnthn nine: OK, will see if I've any energy left after finishing slides 13:27
nine jnthn: thanks :) And no worry, there's still some plain old implementation tasks to do before we have to figure that out 13:28
masak ShimmerFairy: if you really wanted to implement hyperreals, it feels like that wouldn't be all that hard with a (user-defined) class wrapping around Num, adding infinitesimals 13:31
nine jnthn: btw. I really internalized the iterator based approach over the last week of hacking. I just love how we're now both much lazier than before and have saner and simpler semantics at the same time.
ShimmerFairy Yeah, I don't really think it's the right solution to the problem with Inf, though :)
moritz yes, the iterators are really nice 13:32
smls yeah
jnthn nine: Yeah, I worked at "simple but powerful enough" :) 13:33
moritz and simple enough to use directly
jnthn Glad it's working out as hoped :)
moritz: That was also very much a goal
smls btw, I wonder what English word we should use to casually refer to Seq objects in p6doc - "generator"? "sequence"? "lazy sequence" 13:34
jnthn smls: "one-shot" might be good to get in there more than lazy 13:35
smls good point
jnthn I think generator may be a bit too loaded from other languages 13:36
I did use the word a bit here once and found it was already quite overloaded.
And haven't done so again :P
13:36 rurban left
timotimo since my python involvement, "generator" means "coroutine" to me 13:37
nine Why do I get a "Cannot auto-generate a proto method for 'Int' in the setting" when trying to add a multi method Int to array?
timotimo you may want to just put a "proto method Int" in there? 13:38
jnthn timotimo: Yeah, and while a gather/take *does* give a Seq, Seq is more general than that
timotimo aye
nine timotimo: none of the other classes needs it?
But of course the other classes are not repr('VMArray') 13:39
jnthn nine: Should it not be inherited from List?
lizmat nine: the core settings do not auto proto
[Coke] . # messages
yoleaux 20 Aug 2015 22:51Z <lizmat> [Coke]: re github.com/perl6/roast/commit/0452...5bf2e7f183 I have *no* idea, I just reran the generate script
20 Aug 2015 22:51Z <lizmat> [Coke]: I assumed it to be a hash ordering thing
nine jnthn: native array?
jnthn nine: Ooh
13:39 aborazmeh joined, aborazmeh left, aborazmeh joined
nine Ah, just adding the darn proto helped :) 13:40
13:40 muraiki joined
jnthn nine: I'd guess because it inherits from something that doesn't provide a multi, but rather an only 13:40
dalek kudo/glr: 481a5ad | (Stefan Seifert)++ | src/core/native_array.pm:
Add an Int method to native array

Pre-GLR we inherited it from class Iterable		 13:41
moritz wait, native arrays aren't Iterable anymore? 13:42
hoelzro in GLR-land, $[...] is equivalent to [...].item, right?
nine m: say (1,2) === (1,2)
GLRelia rakudo-moar 55b326: OUTPUT«False␤»
camelia rakudo-moar 815fff: OUTPUT«True␤»
nine jnthn: oh, since you're here. Is that ^^^ expected?
jnthn moritz: Yes, but the Iterable role doesn't imply that you can ask for the number of elements 13:43
hoelzro: yes
moritz ah, good
jnthn nine: I think TimToady said that should be True also in glr
nine jnthn: that's...going to be interesting. Not even the slightest idea how to fix that :) 13:44
masak they need to produce the same .WHICH
no?
lizmat masak: they need to be value types, .WHICH is an implementation detail :-)
moritz the case where .is-lazy is False is easy, no?
hoelzro so for [1, 2, 3] { ... } should run 3 iterations, and for $[1, 2, 3] { ... } should run 1? (along with $([1, 2, 3]) and [1, 2, 3].item) 13:45
lizmat moritz: not so
m: [my $, my $, my $][0] = 42
GLRelia rakudo-moar 55b326: OUTPUT«5===SORRY!5=== Error while compiling /tmp/g_s8aft9KI␤Unsupported use of $] variable; in Perl 6 please use $*PERL.version or $*PERL.compiler.version␤at /tmp/g_s8aft9KI:1␤------> 3[my $, my $, my $]7⏏5[0] = 42␤»
camelia rakudo-moar 815fff: OUTPUT«5===SORRY!5=== Error while compiling /tmp/M0hhCiBPqE␤Unsupported use of $] variable; in Perl 6 please use $*PERL.version or $*PERL.compiler.version␤at /tmp/M0hhCiBPqE:1␤------> 3[my $, my $, my $]7⏏5[0] = 42␤»
lizmat m: [my $, my $, my $ ][0] = 42
GLRelia ( no output )
camelia ( no output )
lizmat m: say [my $, my $, my $ ][0] = 42 13:46
GLRelia rakudo-moar 55b326: OUTPUT«42␤»
camelia rakudo-moar 815fff: OUTPUT«42␤»
lizmat so [...] can be mutable inside
moritz lizmat: so it needs to respect the .WHICH of the container, if there's a container, right?
lizmat only if all elements are immutable, do we have a value type
nine ok @arr.list === @arr, "$t array .list returns identity"; # I'm not sure how we can keep this up. .list does now a List.from-iterator(self.iterator) to keep e.g. Str.join from looping infinitely 13:47
lizmat personally, I think we need to deal with it at compile time
in the case of (1,2,3), the code gen should create a immutable subclass of Int that has a custom .WHICH
(well, that would be my approach)
ShimmerFairy subclass of List, you mean?
lizmat ShimmerFairy: correct: s/Int/List/ 13:48
:-)
moritz lizmat: or have a WHICH that includes the WHICH of the container elements
that way even my $a; ($a, 1) === ($a, 1) will return True
lizmat m: my $a = 42; say $a.WHICH
camelia rakudo-moar 815fff: OUTPUT«Int|42␤»
GLRelia rakudo-moar 481a5a: OUTPUT«Int|42␤»
moritz which isn't bad, IMHO
ShimmerFairy I wouldn't mind an immutable class Tuple , fwiw
lizmat m: my $a = 42; say $a.VAR.WHICH
GLRelia rakudo-moar 481a5a: OUTPUT«Scalar|68089432␤»
camelia rakudo-moar 815fff: OUTPUT«Scalar|58390160␤»
ShimmerFairy (which is what TimToady was talking about the other day)
moritz m: say 42.VAR.WHICH
GLRelia rakudo-moar 481a5a: OUTPUT«Int|42␤»
camelia rakudo-moar 815fff: OUTPUT«Int|42␤»
nine ShimmerFairy: where's the difference to a List where all items are bound to containerless values? 13:49
lizmat so yeah, that could work at runtime
ShimmerFairy nine: apparently List isn't immutable, so there's the difference :)
jnthn nine: I think .list on @arr really should return identity; I'd see if we can't fix the join thing another way... 13:50
nine ShimmerFairy: List _is_ immutable. It's the items that are not if they are containers
jnthn nine: Why *is* join a problem? )
nine jnthn: 15:50 < jnthn> nine: Why *is* join a problem? )
ShimmerFairy nine: well, List isn't currently a value type, so as far as P6 is concerned, it's not immutable :)
nine jnthn: I get a weird endless recurion of .list if method list(array:D:) { self }
jnthn nine: Oh, you're on native arrays here rather than Array? 13:51
nine jnthn: yes 13:52
That's basically the only native tests still failing. 13:57
dalek ast/glr: 0bdfd2e | (Stefan Seifert)++ | S09-typed-arrays/native- (2 files):
Need to flatten manually now in list assignment
 13:58
lizmat jnthn: re making [ |<a b c> ] work 13:59
FROGGS jnthn: btw, I made Seq Cool, are you okay with that?
nine FROGGS: you really should have asked if jnthn is cool with that :) 14:00
FROGGS ;o)
14:00 aborazmeh left
lizmat jnthn: I basically removed the sorry from prefix:sym<|> { <sym> <O('%symbolic_unary')> } 14:00
but am at a loss where to continue to get this to work 14:01
I don't see anything with prefix:sym<|> in Actions
FROGGS m: say "forty-two".comb() ~~ Positional; say "forty-two".comb().WHAT 14:02
camelia rakudo-moar 815fff: OUTPUT«True␤(List)␤»
GLRelia rakudo-moar 481a5a: OUTPUT«False␤(Seq)␤»
[Coke] will get an updated daily glr report with all these lovely fixes as soon as the JVM run finishes. Oi.
jnthn lizmat: You don't need anything in actions
FROGGS: Think I'm gool with it
*cool
damn, that ruined the pun
FROGGS :D
nine Everybody be cool
jnthn lizmat: You just write sub prefix:<|)(\x) { x.Slip } in CORE.setting somewhere
lizmat: That should do it
lizmat ok, will do 14:03
ugexe it seems like MAIN($arg, :@args) { } used to accept `--args="x" pos1`, but im seeing now it only works if i do `--args=x --args=x2 pos1`. (in moar-nom). is there a different way to do this, or is it just bugged right now?
FROGGS jnthn: now you're looking like a ghul in pyjamas
14:04 rindolf joined
ugexe as in, for MAIN arguments Positional needs more than 1 element. i just thought it was weird because it happens on nom 14:05
moritz ugexe: should probably coercive in MAIN 14:06
ugexe so just use :$args in the signature?
JimmyZ lizmat: I think prefix | need to be in src/core/precedence.pm too
[Coke] jnthn's al ghul.
lizmat JimmyZ: good point 14:07
nine Oh, of course! array inherits Any's join which does self.list.join. Since self.list returns self we get a nice endless recursion ;) 14:08
dalek ast/glr: b7b35ef | FROGGS++ | S32-str/comb.t:
check that .comb() returns something Iterable
 14:09
nine m: my int @a = 1, 2, 3; @a.Supply(); 14:13
GLRelia ( no output )
camelia rakudo-moar 815fff: OUTPUT«Memory allocation failed; could not allocate 61792 bytes␤»
nine There, same endless recursion in nom ^^^
It's just that on nom much fewer of Any's methods did self.list.foo 14:14
m: my int @a = 1, 2, 3; @a.Parcel();
GLRelia rakudo-moar 481a5a: OUTPUT«Method 'Parcel' not found for invocant of class 'array[int]'␤ in block <unit> at /tmp/q6WKrcrfcV:1␤␤»
camelia rakudo-moar 815fff: OUTPUT«Memory allocation failed; could not allocate 61792 bytes␤»
[Coke] I need to rewrite roast's test_summary in perl6 so I can more easily run the tests in parallel and report on them in the original order.
nine jnthn: ^^^ good enough reason to just kill the array.list returns identity test?
[Coke]: I think few people will try to stop you from doing that ;) 14:15
moritz [Coke]: +1 14:17
[Coke]: it'll make it much easier to diff the outputs 14:18
jnthn nine: Hmm...well, might well be 14:19
nine: Makes me a little confomrtable, somehow, but I can't put my finger on why
skids nine: I rememeber stubbing my toe on that .join problem before too
[Coke] will see about doing that on the incredibly long day on the way to Olten. :) 14:20
.seen pmichaud
yoleaux I saw pmichaud 14 Aug 2015 18:03Z in #perl6: <pmichaud> r: (12,24,13,97,11,10,100).pick(7).say
nine jnthn: the alternative would be to add implementations of all of Any's methods that do the self.list.foo trick
jnthn nine: Aye...that is probably not too expedient
nine jnthn: I can do either. I just don't see a real good reason to require .list to return identity
jnthn nine: Though we may want some of them for performance. 14:21
dalek kudo/glr: 0b1722b | lizmat++ | src/ (3 files):
Enable | as a generic flattener

  $ 6 'say [|<a b c>,|<d e>].perl'
  ["a", "b", "c", "d", "e"]
  jnthn++, JimmyZ++ for support
jnthn lizmat++
Glad it was as easy as hoped :)
nine lizmat++ # I've wished for that for a week :)
lizmat yup, it was *much* easier
nine: yeah, wished for it today as well.. :-) 14:22
jnthn Glad you slipped it in :)
skids Oh yay, glad to see that won't be a wart in the end. 14:24
14:26 mr-foobar joined
dalek ast/glr: ebda77c | (Stefan Seifert)++ | S09-typed-arrays/native- (2 files):
Remove dubious test for native array's list method

I see no good reason for requiring native array's list method to return the native array (it isn't a List after all). Implementing it this way would generate endless recursions in all of Any's methods that follow the method foo() { self.list.foo } pattern. There were a few of those pre-GLR and many more now.		 14:26
nine I decided to just go for forgiveness ;)
smls m: say [1, 2, 3].list.WHAT 14:29
GLRelia rakudo-moar 0b1722: OUTPUT«(Array)␤»
camelia rakudo-moar 815fff: OUTPUT«(Array)␤»
smls nine: Will this ^^ change? 14:30
dalek ast/glr: 09cf434 | lizmat++ | integration/advent201 (3 files):
Use | to slip instead of .Slip
nine smls: no, that's no native array (my int @native_array;)
jnthn smls: No, Array ~~ List
array ain't though
smls ah, ok 14:31
[Coke] likes |<c a m e l i a>
examples is again chewing a lot of CPU - one process, 2.5 cpus, 3CPU-hours. 14:32
not sure if this is expected or not.
14:33 cognominal left
[Coke] nices it. 14:34
moritz [Coke]: it's a "panda install" process 14:35
it surely shouldn't take that long
moritz kills it
[Coke] that's 2 days in a row it's gone crazy, I think. 14:36
dalek pan style="color: #395be5">perl6-examples: 7e850ef | moritz++ | util/update-and-sync:
Set memory and CPU limit in util/update-and-sync

this script has been running wild on hack two days in a row, so better stop it from doing that again		 14:39
[Coke] moritz++ 14:41
moritz .tell [ptc] I've set some ulimits in perl6-examples' update-and-sync, and updated the checkout on hack; that was in a detached HEAD previously. If master sounds wrong to you, please use "git reflog" to restore the old state (and fix the issue otherwise) 14:42
yoleaux moritz: I'll pass your message to [ptc].
moritz ah, I see now it that it operates in detached head state by default; no trouble 14:43
[Coke] sees a copy of vim taking 75% of cpu sustained on hack. weird.
... 100%
stmuk?
moritz [Coke]: probably one doing syntax hilighting through Text::VimColor 14:44
[Coke] gentle reminder, everyone's automated stuff on hack should probably be nice'd.
moritz and CPU time limited
14:45 RabidGravy joined
timotimo your syntax highlighter doesn't need to spend more than two days of cpu time per document! 14:46
dalek ast/glr: a72e84e | (Stefan Seifert)++ | S09-typed-arrays/native- (2 files):
Update test counts after killing .list identity tests
 14:47
14:47 woolfy left
jnthn OK, slides done, I'm going to relax 14:47
Who knows, maybe I'll be lucky enough to sleep... 14:48
o/
[Coke] jnthn++
nine jnthn: wish you luck :)
jnthn Thanks :)
timotimo good luck, jnthn!
dalek p/js: 3b7c094 | (Pawel Murias)++ | src/vm/js/QAST/Compiler.nqp:
Fix bug
p/js: 5814760 | (Pawel Murias)++ | src/vm/js/nqp-runtime/reprs.js:
WIP P6int deserialization
p/js: b6021ce | (Pawel Murias)++ | src/vm/js/QAST/Compiler.nqp:
Compile subcapture rxtype
p/js: 1a24561 | (Pawel Murias)++ | src/vm/js/bin/run_tests:
Add passing test 50
[Coke] pmurias++
nine pmurias++ indeed :) 14:49
[Coke] pmurias: github.com/coke/perl6-roast-data/b...ummary.out shows an npm failure on the last run. haven't bisected to figure out when that started happening. 14:51
pmurias checking that...
dalek osystem: 800afdc | Carlin++ | META.list:
add FCGI; FastCGI module using NativeCall
14:52 FatalNIX left
pmurias [Coke]: that sort of error is caused by debian renaming the node.js executable 14:53
14:54 rurban joined
lizmat also calls it a day 14:55
good night, #perl6!
pmurias [Coke]: there seems to be a nodejs-legacy to solve that
nine lizmat: good night :)
dalek frastructure-doc: 9521e13 | moritz++ | hosts/hack.p6c.org.pod:
Add instructions for running automated jobs
 14:56
moritz [Coke], [ptc], FROGGS, others: github.com/perl6/infrastructure-do...a49fcd7b4d 14:57
[Coke] pmurias: it worked until August 1st. 14:58
possibly someone mucked with node.js on hack that day.
14:58 luiz_lha left
masak congratulations to everyone for prefix:<|> in GLR \o/ 14:58
[Coke] moritz++ thanks. 14:59
moritz colomon: you have a smoker job running that's already used up 32 CPU hours. Is that intentional? If not, please CPU-limit your cron jobs (compare github.com/perl6/infrastructure-do...49fcd7b4d)
pmurias [Coke]: I have no control over that in nqp-js
moritz [Coke], pmurias: should I install nodejs-legacy on hack? 15:01
pmurias moritz: yes 15:02
assuming when don't do any amature radio on hack
15:03 diana_olhovik left
dalek p/js: 88d6626 | (Pawel Murias)++ | src/vm/js/QAST/Compiler.nqp:
Fix bug
 15:04
p/js: 9d8900e | (Pawel Murias)++ | src/vm/js/bin/run_tests:
Run passing test 34
lizmat now that we have | for flattening, I wonder whether we need the one arg rule still # jnthn TimToady 15:05
colomon moritz: not intentional, but I thought we set limits on smoke processes last month? looking now
lizmat m: my @a = (1,2,3); say @a.perl 15:06
GLRelia rakudo-moar 0b1722: OUTPUT«[1, 2, 3]␤»
camelia rakudo-moar 815fff: OUTPUT«[1, 2, 3]<>␤»
lizmat m: my @a = |(1,2,3); say @a.perl # not much worse
GLRelia rakudo-moar 0b1722: OUTPUT«[1, 2, 3]␤»
camelia rakudo-moar 815fff: OUTPUT«5===SORRY!5=== Error while compiling /tmp/I46fPk1bgh␤Arg-flattening | is only valid in an argument list␤at /tmp/I46fPk1bgh:1␤------> 3my @a = |7⏏5(1,2,3); say @a.perl # not much worse␤»
lizmat my @a = |(1,2,3) # feels completely consistent to me 15:07
[Coke] moritz: maybe add "nice" to the list ? 15:08
lizmat really afk&
[Coke] lizmat: ~~
colomon did hack just go down? I suddenly cannot reach it. :\
ShimmerFairy It looks like unnecessary noise to me. prefix:<|> feels more like it's meant for places where single-arg doesn't kick in for you 15:09
[Coke] colomon: I'm on hack.
(my irc client is there)
colomon ssh hack.p6c.org
ssh: connect to host hack.p6c.org port 22: No route to host
[Coke] still able to open new connections from my local box, also. 15:10
colomon and the ssh login I had died.
weird
obviously I’ve still got some sort of connectivity here...
timotimo did the host key for hack.p6c.org recently change?
[Coke] tries some hot tea with lime instead of lemon.
Hey, I've just been roped into doing a Q&A with TimToady at SPW. Feel free to privmsg or email me questions you'd like to see to see answered. 15:14
moritz timotimo: I hope not :-) 15:16
timotimo: my client verifies the ECDA host key, and that didn't change 15:17
timotimo ECDSA key fingerprint is SHA256:zcE9BYoYGXmc2tm+g1eB/SYtHpiFcU+7KMBEVgNDY10.
does that seem right?
also, it's surprisingly difficult to verify fingerprints sometimes 15:18
i tried to ssh to a friend's computer and we had a really tough time to get the same format of fingerprint shown on both machines
moritz timotimo: ssh -v says: "debug1: Server host key: ECDSA 99:47:b8:06:bb:ea:5c:35:37:9b:64:d6:e5:2d:9b:da 15:19
debug1: Host 'hack.p6c.org' is known and matches the ECDSA host key.
"
timotimo debug1: Server host key: ecdsa-sha2-nistp256 SHA256:zcE9BYoYGXmc2tm+g1eB/SYtHpiFcU+7KMBEVgNDY10 15:21
this is what i get instead
see what i mean with regards to fingerprint format? :D
dalek kudo/glr: 05e46f5 | (Stefan Seifert)++ | src/core/Range.pm:
Implement general Range iterator using .pred and .succ

Spec says the Range iterator should just the .succ method to get the next element. So that is what we do if we have no specialized iterator.
15:22 khw joined 15:32 Ven left
nine How can I prevent infix:<minmax>(*@args) from flattening its arguments and thus prevent is (1..100000000000000000 minmax 2..999999999999999999).gist, (1..999999999999999999).gist from hanging? 15:33
JimmyZ nine: how about **args is rw 15:34
**@args is rw
nine: irclog.perlgeek.de/perl6/2015-08-13#i_11051703 # if you missed it 15:36
nine JimmyZ: brilliant! Many thanks!
15:42 abuck05 joined 15:43 Loren_ left 15:46 pmurias left 15:47 Ven joined
dalek kudo/glr: b11bd66 | (Stefan Seifert)++ | src/core/Any-iterable-methods.pm:
Fix almost endless loop on 1..1000000000000 minmax 2..9999999999999

  minmax should not flatten its arguments.
Many thanks to JimmyZ++ for pointing out the correct fix.		 15:48
nine 163 to go
Ven puts down his talk and clones the glr branch 15:50
15:51 carlin joined
carlin timotimo: the incantation you want is: ssh -oFingerprintHash=md5 15:52
timotimo thank you!
that's magical!
also, can you consider giving your fcgi module a different name? there's already a fastcgi module and perhaps yours could be FastCGI::NativeCall or FastCGI::C ? 15:53
carlin that sounds reasonable
I called it FCGI because it uses the same C library and a similar interface as Perl 5's FCGI module but I'm not attached to the name at all 15:54
15:54 abuck05 left 15:55 telex left
JimmyZ m: (1..100000000000000000 minmax 2..999999999999999999).gist 15:56
GLRelia ( no output )
camelia ( no output )
15:56 amurf joined, telex joined
JimmyZ m: say (1..100000000000000000 min 2..999999999999999999).gist 15:56
GLRelia rakudo-moar b11bd6: OUTPUT«1..100000000000000000␤»
camelia rakudo-moar 815fff: OUTPUT«1..100000000000000000␤»
JimmyZ m: say (1..100000000000000000 max 2..999999999999999999).gist
GLRelia rakudo-moar b11bd6: OUTPUT«2..999999999999999999␤»
camelia rakudo-moar 815fff: OUTPUT«2..999999999999999999␤»
JimmyZ m: say (1..100000000000000000 minmax 2..999999999999999999).gist 15:57
GLRelia rakudo-moar b11bd6: OUTPUT«1..999999999999999999␤»
camelia rakudo-moar 815fff: OUTPUT«1..999999999999999999␤»
tony-o it broke 15:58
nine did it? 15:59
15:59 KCL_ joined 16:00 amurf left
dalek kudo/glr: 6d1d307 | (Stefan Seifert)++ | src/core/Range.pm:
Fix "Can't elems a lazy list" on (1e0..3e0).elems

Lazy in general means that we can't know how many elements it will be. In this case we do.		 16:01
JimmyZ nine: I think min/max needs 'is rw' too. 16:02
16:02 raiph joined
nine 162 to go 16:03
JimmyZ: you're probably right. Do you know some tests that would fix? 16:05
raiph <moritz> sigilless vars ... don't force a container .... <nine> that they don't have a container ... nine: moritz is right you've gone too far (sigilless vars *can* be bound to a container)
m: my \array = @; array[3] = 1; say array 16:06
GLRelia rakudo-moar b11bd6: OUTPUT«(Any) (Any) (Any) 1␤»
camelia rakudo-moar 815fff: OUTPUT«(Any) (Any) (Any) 1␤»
16:06 Ven left
raiph m: my \array =@= [1,2,3,4]; array[3] = 1; say array 16:07
GLRelia rakudo-moar 6d1d30: OUTPUT«1 2 3 1␤»
camelia rakudo-moar 815fff: OUTPUT«1 2 3 4 (Any) (Any) 1␤»
JimmyZ I don't, but it seems that using List always uses a bit less memory when we don't need array.
nine: ^^
16:08 ab6tract joined
raiph m: my \array =@= 1,2,3,4; array[3] = 1; say array 16:09
GLRelia rakudo-moar 6d1d30: OUTPUT«1 2 3 1␤»
camelia rakudo-moar 815fff: OUTPUT«1 2 3 1␤»
JimmyZ m: (1e0..*).elems
GLRelia ( no output )
camelia ( no output )
JimmyZ m:say (1 ..*).elems
m:(1 ..*).elems 16:10
moritz m: say (1..*).elems 16:11
GLRelia rakudo-moar 6d1d30: OUTPUT«Inf␤»
camelia rakudo-moar 815fff: OUTPUT«Inf␤»
PerlJam heh
JimmyZ: "m: " is significant :) 16:12
JimmyZ :)
moritz yes, the whitespace is necessary, otherwise nqp::op would trigger the "nqp:" target
ab6tract lizmat: github.com/perl6/roast/commit/ca092df7f9 <---- that explicit itemization makes me sad 16:13
PerlJam wait ... that's needed for glr? 16:14
ab6tract is that going to be permanent going forward? 16:15
PerlJam: I hope not :(
16:15 domidumont left, laben joined
laben hello p6'ers 16:16
ab6tract but probably so.. Array will flatten if it is a single arg?
timotimo huh!
m: say ("circle" => ["a" => 1, "b" => 2, "c" => 3]).perl
GLRelia rakudo-moar 6d1d30: OUTPUT«:circle($[:a(1), :b(2), :c(3)])␤»
camelia rakudo-moar 815fff: OUTPUT«:circle([:a(1), :b(2), :c(3)])␤»
timotimo seems like it already gets itemized there
PerlJam that's what I thought
ab6tract exhales deeply 16:18
timotimo++ # a better approach to the question than holding one's breath
laben nine++ still glr-ing out there? 16:20
hoelzro in post-GLR, does my @a := $[1, 2, 3] make sense? does it result in @a having 1, 2, and 3 as its elements?
laben m: dd $[1, 2, 3] 16:21
GLRelia rakudo-moar 6d1d30: OUTPUT«$[1, 2, 3]␤»
camelia rakudo-moar 815fff: OUTPUT«(Any, Any, Any)␤»
laben m: my @a = $[1, 2, 3]; dd @a
GLRelia rakudo-moar 6d1d30: OUTPUT«@a = [$[1, 2, 3]]␤»
camelia rakudo-moar 815fff: OUTPUT«@a = [Any, Any, Any]<>␤»
nine ab6tract: especially since [] itemizes its items. So I really don't see how the $[] should be necessary
laben m: my @a := $[1, 2, 3]; dd @a
GLRelia rakudo-moar 6d1d30: OUTPUT«[1, 2, 3]␤»
camelia rakudo-moar 815fff: OUTPUT«(Any, Any, Any)␤»
nine laben: well I should shift my focus on making dinner now, before the shops close :) 16:22
ab6tract m: my @a := [1,2,3]; dd @a
camelia rakudo-moar 815fff: OUTPUT«[1, 2, 3]<>␤»
GLRelia rakudo-moar 6d1d30: OUTPUT«[1, 2, 3]␤»
laben m: my @a = [1, 2, 3]; dd @a
camelia rakudo-moar 815fff: OUTPUT«@a = [[1, 2, 3]]<>␤»
GLRelia rakudo-moar 6d1d30: OUTPUT«@a = [1, 2, 3]␤»
ab6tract nine: thank you for confirming that. I was close to losing faith there for a second
ab6tract spins up a blank presentation template. time to prepare for SPW and YAPC::EU! 16:23
nine Oh yes, that's still a big TODO for this weekend :(
hoelzro I'm just wondering with my @a := $[1, 2, 3]; my @b = @a, 4, 5; if @a would flatten in @b's initialization 16:24
nine it shouldn't
m: my @a := $[1, 2, 3]; my @b = @a, 4, 5; say @b.perl; 16:25
GLRelia rakudo-moar 6d1d30: OUTPUT«[$[1, 2, 3], 4, 5]␤»
camelia rakudo-moar 815fff: OUTPUT«[Any, Any, Any, 4, 5]<>␤»
nine m: my @a := $[1, 2, 3]; my @b = |@a, 4, 5; say @b.perl;
GLRelia rakudo-moar 6d1d30: OUTPUT«[1, 2, 3, 4, 5]␤»
camelia rakudo-moar 815fff: OUTPUT«5===SORRY!5=== Error while compiling /tmp/80T__LT92V␤Arg-flattening | is only valid in an argument list␤at /tmp/80T__LT92V:1␤------> 3my @a := $[1, 2, 3]; my @b = |7⏏5@a, 4, 5; say @b.perl;␤»
nine Explicit flattening FTW
hoelzro so the "flattening-ness" of $[...] is attached the object? it's not just sugar for [...].item?
PerlJam glr++
timotimo what's wrong with rakudo/nom in there?
why do things turn into Any there?
nine m: my @a := [1, 2, 3]; my @b = @a, 4, 5; say @b.perl;
GLRelia rakudo-moar 6d1d30: OUTPUT«[$[1, 2, 3], 4, 5]␤»
camelia rakudo-moar 815fff: OUTPUT«[1, 2, 3, 4, 5]<>␤»
nine m: my @a = [1, 2, 3]; my @b = @a, 4, 5; say @b.perl;
GLRelia rakudo-moar 6d1d30: OUTPUT«[$[1, 2, 3], 4, 5]␤»
camelia rakudo-moar 815fff: OUTPUT«[[1, 2, 3], 4, 5]<>␤»
nine all the same
timotimo: I have no idea...and I don't particularly care ;) I'm really just focusing on GLR 16:26
laben File::Find problem is golfed down to this thing m: my @a = 1..3; my @b = 2..4; say @a >>~~<< @b>>.pred 16:27
m: my @a = 1..3; my @b = 2..4; say @a >>~~<< @b>>.pred
GLRelia rakudo-moar 6d1d30: OUTPUT«True True True␤»
camelia rakudo-moar 815fff: OUTPUT«True True True␤»
laben m: my @a = 1..3; my @b = 2..4; say @a >>~~<< @b.map(*.pred)
GLRelia rakudo-moar 6d1d30: OUTPUT«This Seq has already been iterated, and its values consumed␤ in block <unit> at /tmp/tf1eS5jF_8:1␤␤»
camelia rakudo-moar 815fff: OUTPUT«True True True␤»
laben nine: is this expected?
ab6tract m: my @a = 1..3; my @b = 2..4; say @a >>~~<< @b.list.map(*.pred)
GLRelia rakudo-moar 6d1d30: OUTPUT«This Seq has already been iterated, and its values consumed␤ in block <unit> at /tmp/KElQqvaDeP:1␤␤»
camelia rakudo-moar 815fff: OUTPUT«True True True␤»
ab6tract laben: that's an interesting corner case indeed 16:28
nine laben: I'm inclined to say yes. That would be one of those cases where you have to store the list yourself.
laben but @b is an Array, why would i expect it to become a Seq after .map? 16:29
ab6tract m: my @a = 1..3; my @b = (2..4)>>.pred; say @a >>~~<< @b
GLRelia rakudo-moar 6d1d30: OUTPUT«True True True␤»
camelia rakudo-moar 815fff: OUTPUT«True True True␤»
nine laben: in other words: being explicit about wanting that list to be stored. A big reason for the GLR was that we stored always, even when in most cases we never reused the produced values. This cost a lot of performance.
tony-o m: say 'hello'.split('').perl
camelia rakudo-moar 815fff: OUTPUT«("", "h", "e", "l", "l", "o", "")␤»
GLRelia rakudo-moar 6d1d30: OUTPUT«("", "h", "e", "l", "l", "o", "").iterator␤»
hoelzro in github.com/perl6/roast/commit/ca09...c4ea2424f, is the new $ prefix on the circle value necessary? 16:30
tony-o should there be empty '' in there?..
hoelzro sorry for the all the questions, I'm just trying to familiarize myself with the GLR
on the off chance I have time to work on it this weekend, but also for the WS next week
nine m: my @a = 1..3; my @b = (2..4)>>.pred; say @a >>~~<< @b.map(*.pred).List
camelia rakudo-moar 815fff: OUTPUT«False False False␤»
GLRelia rakudo-moar 6d1d30: OUTPUT«False False False␤»
laben nine: why doesn't >> create a Seq too, then? 16:31
PerlJam tony-o: yes. hold on a sec, let me find where TimToady said as much.
timotimo hyperops are eagerer than eager
people - including me - seem to forget this quite often :)
laben m: my @a = 1..3; my @b = 2..4; say @a >>~~<< @b.map(*.pred).List
GLRelia rakudo-moar 6d1d30: OUTPUT«True True True␤»
camelia rakudo-moar 815fff: OUTPUT«True True True␤»
timotimo hm, though a bunch of hyperops chained don't really need to store stuff on every step of the way 16:33
nine I'd say it's mostly a matter of finding the time to refactor them.
First priority for me is to get stuff working
laben i understand eager and lazy, but the problem here is that somehow the Seq is iterated multiple times even though i would expect only once...
PerlJam tony-o: RT#112868 16:34
rt.perl.org/Ticket/Display.html?id=112868
nine laben: feel free to investigate further :) There could still be a bug or five somewhere in there.
PerlJam plays the part of the bot for a second
tony-o PerlJam thank you 16:35
nine laben: 10 days ago I knew pretty much nothing about the GLR or hyper operators (just learned about the >> << thing two days ago) or much else. So I would be very surprised if everything I did in the mean time was even vaguely correct. 16:36
16:36 carlin left
laben nine: a hint to know where to look for >>~~<< op? 16:36
16:37 synbot6 joined
nine laben: src/core/metaops.pm line 384 16:38
ab6tract m: (1,*,2).WHAT.perl.say
camelia rakudo-moar 815fff: OUTPUT«Parcel␤»
GLRelia rakudo-moar 6d1d30: OUTPUT«List␤»
16:40 lucasb joined
ab6tract hoelzro: that same thing just about gave me a heart attack! but no, the explicit itemization should not be necessary. not sure what lizmat ran into that led her to add it 16:40
m: say ('circle' => [<k v r>]).perl 16:41
GLRelia rakudo-moar 6d1d30: OUTPUT«:circle($["k", "v", "r"])␤»
camelia rakudo-moar 815fff: OUTPUT«:circle(["k", "v", "r"])␤»
PerlJam laben: When you List-ify the Seq, you can iterate any number of times.
ab6tract: probably the first attempt to fix was to add explicit itemization, and then when that didn't work, she added the .Slip and since that *did* work ... commit! 16:42
ab6tract laben: afaict it's that the hyper is trying to consume the map'd Seq, which explodes
m: my @a = 1..3; my @b = 2..4; say @a >>~~<< @b.map(*.pred).list
GLRelia rakudo-moar 6d1d30: OUTPUT«True True True␤»
camelia rakudo-moar 815fff: OUTPUT«True True True␤»
ab6tract (I tried something similar earlier, but put the list-ify in the wrong place) 16:43
nine m: my @a = 1..3; my @b = (2..4)>>.pred; say (@a >>~~<< @b).map(*.pred)
GLRelia rakudo-moar 6d1d30: OUTPUT«False False False␤»
camelia rakudo-moar 815fff: OUTPUT«False False False␤»
nine m: my @a = 1..3; my @b = (2..4)>>.pred; say @a >>~~<< (@b.map(*.pred))
GLRelia rakudo-moar 6d1d30: OUTPUT«This Seq has already been iterated, and its values consumed␤ in block <unit> at /tmp/43KpsbDp8d:1␤␤»
camelia rakudo-moar 815fff: OUTPUT«False False False␤»
FROGGS o/
ab6tract m: my @a = 1..3; my @b = (2..4)>>.pred; say @a >>~~<< (my @c = @b.map(*.pred))
GLRelia rakudo-moar 6d1d30: OUTPUT«False False False␤»
camelia rakudo-moar 815fff: OUTPUT«False False False␤»
ab6tract :)
m: my @a = 1..3; my @b = (2..4)>>.pred; say @a >>~~<< my @c = @b.map(*.pred) 16:44
GLRelia rakudo-moar 6d1d30: OUTPUT«False False False␤»
camelia rakudo-moar 815fff: OUTPUT«False False False␤»
ab6tract (overly cautious parens)
though stylistically I would include them for clarity's sake 16:46
lucasb i'm newbie in IRC, so do you know if there is a way to put both GLRelia and camelia in the same /query window? 16:48
16:49 rurban left, zakharyas left
PerlJam lucasb: I think you can do "/msg nick1,nick2 foo", but it's not something I've ever done. 16:51
dalek ast/glr: 3ee1cd0 | PerlJam++ | integration/advent2012-day20.t:
Remove unneeded explicit itemization
 16:54
hoelzro ab6tract: alright, thanks for confirming!
nine++ and PerlJam++ are just killing it lately on the GLR stuff 16:55
(jnthn++ too!)
PerlJam hoelzro: I just want to know who's going to pull the trigger on merging GLR into nom (and master for roast). 16:56
[Coke] FFFFFFFFFFFFFFUUUUUUUUUU
PerlJam (might also be a good time to rename nom to master if that's in the cards)
[Coke] has to rerun the daily run today because he's an idiot. 16:57
ab6tract PerlJam: I don't think there will be a merge, but rather s/glr/master
that's as I understood it
ShimmerFairy ab6tract: that was just a jocular suggestion once, that's not likely to happen
PerlJam ab6tract: oh. whichever ... I'm waiting on the release until it happens. And if its put off until Sunday, someone else may have to do the release. 16:58
ab6tract ShimmerFairy: no, afaik TimToady and jnthn both want 'glr' to become 'master'
ShimmerFairy I was there when jnthn made the suggestion in jest, and I don't recall TimToady saying anything. 16:59
16:59 mjgardner joined
PerlJam ShimmerFairy: how do you know it was in jest? ;) 16:59
ab6tract ShimmerFairy: I was there too, and remember it differently :)
ShimmerFairy PerlJam: because I was pointing out how having a years-old "_new_ object model" branch was kinda silly :P
ab6tract but not enough time to dig through the backlog
it has been mentioned more than once, to be sure 17:00
dalek rl6-roast-data: e094bf2 | coke++ | perl6_pass_rates.csv:
Remove run from yesterday with bad nqp req.

Did another run after that.
ShimmerFairy there were later clarifications that it was unlikely, as well
ab6tract does anyone have exciting examples of Whatever (but not WhateverCode) outside of Range?
PerlJam ShimmerFairy: everyone I know in Baton Rouge Louisian calls the I-10 bridge over the Mississippi River the "new bridge". that bridge has got to be 50+ years old. :)
ab6tract ShimmerFairy: okay, maybe I missed those
RabidGravy are the details important? except by way of someone knowing from what to make a release? 17:01
ShimmerFairy PerlJam: yeah, I still remember TimToady's(?) example from Oxford :)
smls ab6tract: array slicing
PerlJam exactly :)
ab6tract smls: thanks
[Coke] I would recommend combinging "merging glr to mainline" with "making master mainline" 17:02
ShimmerFairy RabidGravy: as long as the divergent work between nom and glr come together in the end, not really :)
[Coke] ugh.
I would recommend NOT combinging "merging glr to mainline" with "making master mainline"
*combining
because we still don't have a clear picture of the git repo layout post christmas.
smls ab6tract: also, list repetition ($foo xx *) 17:03
[Coke] kicks off YA daily run, arglebargles.
tony-o is there a way to anonymous sub a >> 17:04
m: 'hello'.index('e')>>.&(sub ($pos) { $pos.say; });
GLRelia rakudo-moar 6d1d30: OUTPUT«1␤»
camelia rakudo-moar 815fff: OUTPUT«1␤»
tony-o guess so
full blown perl6 17:05
ab6tract smls: any thoughts on when such a list repetition would be useful? ;) 17:06
PerlJam tony-o: it's weird that you used >> on index instead of indices :)
ab6tract: it's used in the implementation of .rotor() 17:07
lucasb PerlJam: thanks. /msg works but not the exact way I wanted
17:08 espadrine left
PerlJam :q 17:08
oops
smls m: my @rnd := rand xx *; say @rnd[0..5]; # ab6tract
camelia rakudo-moar 815fff: OUTPUT«0.562594830679797 0.589118153674792 0.210635966825477 0.678320062315838 0.931913591991977 0.340109058192961␤»
GLRelia rakudo-moar 6d1d30: OUTPUT«Type check failed in binding; expected 'Positional' but got 'Seq'␤ in block <unit> at /tmp/Pd5KeKJjhU:1␤␤»
17:09 rurban joined
ab6tract smls, PerlJam: thanks! 17:09
m: my @a = [[50..55],[1..5]],[[60..66],[1..6]],[[70..77],[1..7]]; dd @a[*][0]
camelia rakudo-moar 815fff: OUTPUT«@a = [[50, 51, 52, 53, 54, 55], [1, 2, 3, 4, 5]]␤»
GLRelia rakudo-moar 6d1d30: OUTPUT«@a = $[$[50, 51, 52, 53, 54, 55], $[1, 2, 3, 4, 5]]␤»
tony-o PerlJam: always curious of different ways to do some of this stuff..i kind of like that more than the if $str.index -> $pos { } syntax 17:10
dalek kudo/glr: 1fdc7a8 | (Jimmy Zhuo)++ | src/core/Any-iterable-methods.pm:
Added sub min/max args with 'is rw'

We don't need Array here, List is enough, which is the same as sub minmax()		 17:11
kudo/glr: 5873e1a | niner++ | src/core/Any-iterable-methods.pm:
Merge pull request #507 from zhuomingliang/patch-5

Added sub min/max args with 'is rw'
ab6tract m: my @a = [50..55],[60..66],[70..77]; dd @a[*][1] # I would have expected 51,61,71 .... 17:12
GLRelia rakudo-moar 6d1d30: OUTPUT«@a = $[60, 61, 62, 63, 64, 65, 66]␤»
camelia rakudo-moar 815fff: OUTPUT«@a = [60, 61, 62, 63, 64, 65, 66]␤»
tony-o m: 'hello'.index('e')>>.&({ .say; }); 17:13
GLRelia rakudo-moar 6d1d30: OUTPUT«1␤»
camelia rakudo-moar 815fff: OUTPUT«1␤»
smls m: my @a = [50..55],[60..66],[70..77]; dd @a[*]»[1] # ab6tract 17:14
camelia rakudo-moar 815fff: OUTPUT«(51, 61, 71)␤»
GLRelia rakudo-moar 6d1d30: OUTPUT«(51, 61, 71)␤»
smls m: my @a = [50..55],[60..66],[70..77]; dd @a[*;1] # ab6tract 17:15
GLRelia rakudo-moar 6d1d30: OUTPUT«Method 'lol' not found for invocant of class 'List'␤ in block <unit> at /tmp/IHxwjGJyoN:1␤␤»
camelia rakudo-moar 815fff: OUTPUT«(51, 61, 71)␤»
PerlJam tony-o: just don't rely on side-effects if you really need to use >> like that.
tony-o: for instance ...
m: 'hello cruel world'.indices('l')>>.&({ .say });
GLRelia rakudo-moar 6d1d30: OUTPUT«15␤3␤10␤2␤»
camelia rakudo-moar 815fff: OUTPUT«15␤3␤10␤2␤»
timotimo really, you want to use the multi-dimensional slice syntax for that, as smls has shown
ab6tract ahh....! [][] is not equivalent to [;]
timotimo very muhc not
much not*
tony-o PerlJam++ 17:16
17:16 LitterallyTriggr joined
LitterallyTriggr Hi 17:17
has the perl6 performance been fixed for debian
and other linux distros
PerlJam lucasb: define "fixed" :)
ab6tract so in my earlier broken example, the first [*] is just ignored, and it takes the [1] of the array
PerlJam er, LitterallyTriggr
ab6tract which explains why I could add as many of them as I wanted and nothing would change :)
tony-o m: my $str = 'hello literally'; $str.index('l')>>.&({ .say; $str.index('l', $_+1)>>.&?BLOCK; });
GLRelia rakudo-moar 5873e1: OUTPUT«2␤3␤6␤12␤13␤␤The 'gimme' method was an internal method used by rakudo before the Great␤List Refactor. The fact that you are seeing this message, means that you␤have code that was using that unsupported rakudo internal API.␤␤Please refa…»
camelia rakudo-moar 815fff: OUTPUT«2␤3␤6␤12␤13␤»
LitterallyTriggr Slow compiling and execution times
tony-o PerlJam: i know there is indices :-), just interesting 17:18
raiph LitterallyTriggr: what's your perl6 -v ?
LitterallyTriggr tony-o: BLOCK literal
tony-o LitterallyTriggr: huh?
LitterallyTriggr This is perl6 version 2014.07 built on parrot 6.6.0 revision 0
PerlJam LitterallyTriggr: I understand the problem, I don't know what you mean by "fixed". The compilation and execution times are getting better. They are adequate for most of my purposes
LitterallyTriggr: yikes!
LitterallyTriggr they're horrendous.
tony-o you might want to build p6 with rakudobrew LitterallyTriggr 17:19
LitterallyTriggr Let me guess. I'm severely out of date?
ab6tract LitterallyTriggr: indeed. Parrot was deprecated earlier this year, and has not been a preferred vm fro much longer than that
tony-o by over a year now LitterallyTriggr
LitterallyTriggr: github.com/tadzik/rakudobrew
LitterallyTriggr I might hold out for now 17:20
Wait for perl6 to get more adoption 17:21
tony-o you can parse json with perl6 already, what more adoption do you need, really?
PerlJam LitterallyTriggr: it's fun to play with in the mean time :)
LitterallyTriggr tony-o: I rather use Javascript with Node.js
raiph LitterallyTriggr: a current rakudo will be a fundamentally different experience
PerlJam LitterallyTriggr: Do you use Perl 5 or Python?
LitterallyTriggr both 17:22
I prefer Java to them all.
tony-o sadist
PerlJam LitterallyTriggr: You can use Perl 5 and/or Python from within Perl 6 with the Inline::Perl5 and Inline::Python modules. Quite handy that.
LitterallyTriggr p6: def hi(){say("hi");} my $v = &hi; $v();
GLRelia rakudo-moar 5873e1: OUTPUT«5===SORRY!5=== Error while compiling /tmp/tmpfile␤Strange text after block (missing semicolon or comma?)␤at /tmp/tmpfile:1␤------> 3def hi(){say("hi");}7⏏5 my $v = &hi; $v();␤ expecting any of:␤ infix␤ infix stopper…»
camelia rakudo-moar 815fff: OUTPUT«5===SORRY!5=== Error while compiling /tmp/tmpfile␤Strange text after block (missing semicolon or comma?)␤at /tmp/tmpfile:1␤------> 3def hi(){say("hi");}7⏏5 my $v = &hi; $v();␤ expecting any of:␤ infix␤ infix stopper…»
ab6tract m: sub hi(){say("hi");} my $v = &hi; $v() 17:23
GLRelia rakudo-moar 5873e1: OUTPUT«5===SORRY!5=== Error while compiling /tmp/z3e1Xuoynn␤Strange text after block (missing semicolon or comma?)␤at /tmp/z3e1Xuoynn:1␤------> 3sub hi(){say("hi");}7⏏5 my $v = &hi; $v()␤ expecting any of:␤ infix␤ infix stop…»
camelia rakudo-moar 815fff: OUTPUT«5===SORRY!5=== Error while compiling /tmp/h90S6Et_oP␤Strange text after block (missing semicolon or comma?)␤at /tmp/h90S6Et_oP:1␤------> 3sub hi(){say("hi");}7⏏5 my $v = &hi; $v()␤ expecting any of:␤ infix␤ infix stop…»
raiph LitterallyTriggr: if your interest is as a user, not contributor, waiting makes sense too because it continually improves
LitterallyTriggr ^
tony-o and the syntax changes week to week
LitterallyTriggr What's wrong with my syntax
p6: def hi(){say("hi");} my $v = &hi(); $v(); 17:24
GLRelia rakudo-moar 5873e1: OUTPUT«5===SORRY!5=== Error while compiling /tmp/tmpfile␤Strange text after block (missing semicolon or comma?)␤at /tmp/tmpfile:1␤------> 3def hi(){say("hi");}7⏏5 my $v = &hi(); $v();␤ expecting any of:␤ infix␤ infix stopper…»
camelia rakudo-moar 815fff: OUTPUT«5===SORRY!5=== Error while compiling /tmp/tmpfile␤Strange text after block (missing semicolon or comma?)␤at /tmp/tmpfile:1␤------> 3def hi(){say("hi");}7⏏5 my $v = &hi(); $v();␤ expecting any of:␤ infix␤ infix stopper…»
lucasb "def"? So you *do* like Python :)
tony-o need a ; after the block end for the one liners LitterallyTriggr
17:24 rurban_ left
LitterallyTriggr p6: def hi(){say("hi");}; my $v = &hi; $v(); 17:24
GLRelia rakudo-moar 5873e1: OUTPUT«5===SORRY!5=== Error while compiling /tmp/tmpfile␤Undeclared routines:␤ &hi used at line 1␤ def used at line 1␤ hi used at line 1␤␤»
camelia rakudo-moar 815fff: OUTPUT«5===SORRY!5=== Error while compiling /tmp/tmpfile␤Undeclared routines:␤ &hi used at line 1␤ def used at line 1␤ hi used at line 1␤␤»
tony-o m: sub hi { 'hi'.say; }; my $v = &hi; $v();
camelia rakudo-moar 815fff: OUTPUT«hi␤»
GLRelia rakudo-moar 5873e1: OUTPUT«hi␤»
LitterallyTriggr That is what I do like about Perl6
Assigning functions to variables 17:25
PerlJam
.oO( which you can do in loads of other languages too)
17:25 llfourn left
LitterallyTriggr I can dynamically reassign a variable to a new function on the fly to make a more cryptic program that is harder to understand 17:25
PerlJam: Java?
;)
(No reflectionP)
17:25 xinming left
PerlJam and you *like* Java? 17:25
raiph LiterallyTriggr: if you get an error message, the ⏏ tries to point to the exact location
[Coke] j: say "hi" # from rakudo running on the JVM. 17:26
GLRelia rakudo-jvm 5873e1: OUTPUT«Can't open perl script "/home/steve/rakudo-inst/bin/eval-client.pl": No such file or directory␤»
camelia rakudo-jvm 815fff: OUTPUT«hi␤»
[Coke] GLRelia, maybe you could ignore things you can't run. :P
LitterallyTriggr Java is a nice language.
tony-o lol
LitterallyTriggr Reflection is a bit confusing but I'm learning it.
p6: sub hi(){say("hi");}; my $v = &hi; $v(); sub bye(){say("bye");}; $v = &bye; $v(); 17:27
GLRelia rakudo-moar 5873e1: OUTPUT«hi␤bye␤»
camelia rakudo-moar 815fff: OUTPUT«hi␤bye␤»
LitterallyTriggr Perl6 can finally be used to write an emulator.
No more switch cases. Use a noun with an array instead.
17:27 xinming joined
PerlJam "finally"? You're not even hitting a feature that's changed much since close to the first functional implementations. 17:28
LitterallyTriggr Perl6 performance pickups are great enough to do it.
Perl5 wasn't fast enough.
It's simply a change from a custom interpreter to using the JVM / a propper VM 17:29
You could write one in BrainFuck but it would have massive timing issues
Does Perl6 have OpenGL bindings yet? 17:30
I know ACME is being ported over.
Found it: POGL 17:31
lucasb Wouldn't it look better if "*@a" were non-flattening and "**@a" were flattening? That would give the impression that "**" is "one step further". What do you think?
ab6tract lucasb: is it currently the other way around? 17:32
lucasb ab6tract: just a second, let me double check :)
17:33 xinming left
smls lucas: I guess it's a matter of making the more common one shorter 17:33
LitterallyTriggr I'm going to ask the stupid question of the year. Can Perl6 generate custom packets / packet payloads and send them over standard sockets?
IE things like generating SYN, ACK, ARP
17:34 xinming joined
LitterallyTriggr Specifically without external libraries 17:34
lucasb ab6tract: yes, it is the other way around
17:34 Ven joined
RabidGravy LitterallyTriggr, no not at the present 17:35
LitterallyTriggr RabidGravy: is there plans to support that?
It would open Perl6 up to SDN uses
RabidGravy to be honest unlikey because it is something that would have to be provided by a VM and some of the targetted VMs will never support that 17:36
making a library to do it wouldn't be too hard though
LitterallyTriggr At that point you might aswell drop Perl6 then
RabidGravy fair enough 17:37
raiph m: say -> *@a {@a.perl}(1,[2,3,[4,5]]); say -> **@a {@a.perl}(1,[2,3,[4,5]]);
GLRelia rakudo-moar 5873e1: OUTPUT«[1, 2, 3, $[4, 5]]␤[1, $[2, 3, $[4, 5]]]␤»
camelia rakudo-moar 815fff: OUTPUT«[1, [2, 3, [4, 5]]]<>␤(1; 2, 3, [4, 5])␤»
LitterallyTriggr I do admit I am liking how Perl6 is turning out 17:38
ab6tract notes the absence of []<> syntax in GLR and rejoices
17:39 domidumont joined
ab6tract m: my $b = EVAL (* xx 9) # damn, the evil can only go so far... but, a good example of how WhateverCode's are compiler transforms 17:40
GLRelia rakudo-moar 5873e1: OUTPUT«5===SORRY!5=== Error while compiling EVAL_0␤Two terms in a row␤at EVAL_0:1␤------> 3Whatever<140087682768992>7⏏5 Whatever<140087682768992> Whatever<1400␤ expecting any of:␤ infix␤ infix stopper␤ statement end…»
camelia rakudo-moar 815fff: OUTPUT«5===SORRY!5=== Error while compiling EVAL_0␤Two terms in a row␤at EVAL_0:1␤------> 3Whatever<140103699014488>7⏏5 Whatever<140103699014488> Whatever<1401␤ expecting any of:␤ infix␤ infix stopper␤ statement end…»
ab6tract wait, forgot the question mark at the end of that statement 17:41
LitterallyTriggr loil
FROGGS huh 17:43
a Seq with zero elems is Trueish?
m: say so Seq.new 17:44
GLRelia rakudo-moar 5873e1: OUTPUT«Too few positionals passed; expected 2 arguments but got 1␤ in block <unit> at /tmp/VF0BWq1jRV:1␤␤»
camelia rakudo-moar 815fff: OUTPUT«5===SORRY!5=== Error while compiling /tmp/OH_gQnZcqg␤Undeclared name:␤ Seq used at line 1. Did you mean 'Set'?␤␤»
17:45 LitterallyTriggr left, amurf joined
ab6tract m: my $b = * * * * *; say $b( 3 xx 3 ) 17:45
GLRelia rakudo-moar 5873e1: OUTPUT«Too few positionals passed; expected 3 arguments but got 1␤ in block <unit> at /tmp/v8l0T3JBJJ:1␤␤»
camelia rakudo-moar 815fff: OUTPUT«Too few positionals passed; expected 3 arguments but got 1␤ in block <unit> at /tmp/tpokhQbDpu:1␤␤»
ab6tract so it still needs a | in GLR 17:46
FROGGS nine / jnthn: Seq is missing a .Bool, right? 17:48
17:50 amurf left
FROGGS nine / jnthn: either that or grep shouldn't return a Seq... 17:52
m: say so (^42).List 17:53
GLRelia rakudo-moar 5873e1: OUTPUT«1␤»
camelia rakudo-moar 815fff: OUTPUT«True␤»
moritz huh, &so should never return 1
FROGGS: would need to be self.list.Bool
FROGGS moritz: I can fix the List.Bool easily... 17:54
moritz: the other comment was about Seq.Bool?
moritz FROGGS: Seq.Bool would need to return self.list.Bool 17:55
FROGGS mkay
testing this now
ab6tract moritz: ooc, why .list and not .List ?
I'm not sure what the distinction between coercer and constructor are in this context 17:56
s/are/si
ab6tract wonders why he even bothers .. ;)
moritz ab6tract: .list is cached 17:57
hoelzro this ticket (rt.perl.org/Ticket/Display.html?id=63350) no longer applies for GLR, right?
ab6tract ah. cached on the Seq object?
moritz ab6tract: yes
17:57 jack_rabbit_ joined
hoelzro .say for (1, 2, 3).item should now print 3 lines? 17:57
17:57 jack_rabbit_ left
smls I the language of the design docs, .list is neither a coercer nor a composer, but a "contextualizer". 17:58
17:58 muraiki left, Ven left
ab6tract smls: intriguing 17:58
smls m: say [1, 2, 3].list.WHAT 17:59
GLRelia rakudo-moar 5873e1: OUTPUT«(Array)␤»
camelia rakudo-moar 815fff: OUTPUT«(Array)␤»
smls probably because of that ^^
m: my @a = 1, 2, 3; @a.list»++; say @a 18:00
GLRelia rakudo-moar 5873e1: OUTPUT«2 3 4␤»
camelia rakudo-moar 815fff: OUTPUT«2 3 4␤»
smls i.e. it may return the object itself, if it is already sufficiently list'y
"Note that, since these are coercions to roles, they are allowed to return any actual type that does the role in question." -- design.perl6.org/S03#line_2476 18:02
ab6tract yowch! I had no idea the hotel options in Olten were so darn expensive :(
hopefully that won't affect my expensing of said hotel! 18:05
btw, where are the cool kids staying in Granada? 18:09
18:11 ChoHag joined 18:16 rangerprice joined
ab6tract m: my $b = * + *; say $b; # I could have sworn that recently I was seeing the actual transformed block via .gist 18:19
GLRelia rakudo-moar 5873e1: OUTPUT«WhateverCode.new␤»
camelia rakudo-moar 815fff: OUTPUT«WhateverCode.new␤»
ChoHag Does a subclass have direct access to its parent's attributes?
moritz no
otherwise subclass would break encapsulation
*subclassing
ab6tract is there a mechanism for getting the actual block? 18:20
moritz m: say { $^a + $^b }.perl
GLRelia rakudo-moar 5873e1: OUTPUT«-> $a, $b { #`(Block|60784936) ... }␤»
camelia rakudo-moar 815fff: OUTPUT«-> $a, $b { #`(Block|58246464) ... }␤»
moritz m: say { $^a + $^b }.gist
GLRelia rakudo-moar 5873e1: OUTPUT«-> $a, $b { #`(Block|47227176) ... }␤»
camelia rakudo-moar 815fff: OUTPUT«-> $a, $b { #`(Block|48548768) ... }␤»
moritz ab6tract: I think that only works for regexes
18:21 xinming left
ab6tract moritz: okay, that must be what I was thinking of... so no means for getting the transformed block back from a whatevercode currently 18:21
(and you are totally right! I wasn't expecting the actual code in the block, but rather the signature plus the #`(Block|stuff) 18:22
18:23 xinming joined
ab6tract thanks for helping moritz :) 18:23
ChoHag Do you need a method to do so if the parent trusts the subclass, or does trust give access to the attributes? 18:24
rangerprice Hi
How about low level and system programming in perl ? 18:25
18:27 ab6tract left
masak rangerprice: I don't see why not. 18:29
rangerprice Hi masak, how are you ? :) 18:30
18:32 brrt joined
laben .tell nine is it intented for .elems to consume a Seq? if it is, the code in src/core/metaops.pm line 388-389 will need to change. i dont think it's right for hypers to consume Seq multiple times 18:36
yoleaux laben: I'll pass your message to nine.
18:41 nowan left
dalek kudo/glr: 6f9ce0b | FROGGS++ | src/core/List.pm:
make List.Bool return a boolean, not a number
 18:43
kudo/glr: d6049e4 | FROGGS++ | src/core/Seq.pm:
add Seq.Bool, so we can boolify the result of e.g. grep

  moritz++		 18:44
18:46 nowan joined 18:48 zakharyas joined 18:58 cognominal joined
FROGGS we are down to 155 failing test files now 19:00
brrt \o/
[Coke] jeez, I'm still trying to get one daily run collected. :) 19:02
raiph ChoHag: afaict trust is only for providing access to private methods, not attributes; so you can set up a private accessor and share that only with trusted classes 19:04
nine FROGGS++ # epic! 19:07
yoleaux 18:36Z <laben> nine: is it intented for .elems to consume a Seq? if it is, the code in src/core/metaops.pm line 388-389 will need to change. i dont think it's right for hypers to consume Seq multiple times
19:09 pullphinger15 joined 19:11 brrt left 19:13 pullphinger15 left
nine laben: indeed. I think the whole sub could use a rework to make better use of the iterators 19:17
Seq.Bool could be optimized as well, since we should only need to pull-one to know the result. No changes after that. 19:18
19:18 dwarring joined, pullphinger joined, pullphinger left 19:19 pullphinger joined, pullphinger left
nine Ok, back to my girlfriend on the terrace now ;) 19:19
FROGGS m: my $foo = "FOO"; my $bar = "BAR"; my $gorch = "foo bar"; say «$foo $gorch $bar» 19:20
GLRelia rakudo-moar d6049e: OUTPUT«FOOfoobarBAR␤»
camelia rakudo-moar 815fff: OUTPUT«FOOfoo barBAR␤»
FROGGS m: my $foo = "FOO"; my $bar = "BAR"; my $gorch = "foo bar"; say «$foo $gorch $bar».perl
GLRelia rakudo-moar d6049e: OUTPUT«("FOO", ("foo", "bar"), "BAR")␤»
camelia rakudo-moar 815fff: OUTPUT«("FOO", ("foo", "bar"), "BAR")␤»
FROGGS m: my $foo = "FOO"; my $bar = "BAR"; my $gorch = "foo bar"; say «$foo $gorch $bar».elems
camelia rakudo-moar 815fff: OUTPUT«3␤»
GLRelia rakudo-moar d6049e: OUTPUT«3␤»
FROGGS m: my $foo = "FOO"; my $bar = "BAR"; my $gorch = "foo bar"; say (@ = «$foo $gorch $bar»).elems 19:21
GLRelia rakudo-moar d6049e: OUTPUT«3␤»
camelia rakudo-moar 815fff: OUTPUT«4␤»
FROGGS m: my $foo = "FOO"; my $bar = "BAR"; my $gorch = "foo bar"; say (@ = «$foo $gorch $bar»).perl
GLRelia rakudo-moar d6049e: OUTPUT«["FOO", $("foo", "bar"), "BAR"]␤»
camelia rakudo-moar 815fff: OUTPUT«["FOO", "foo", "bar", "BAR"]<>␤»
19:24 domidumont left
laben .tell nine both map and grep return Seq, but couldn't the generated Seq already know its number of elems? after all .map applies to every item while .grep knows wheter an item passes the test and then gets included or not 19:25
yoleaux laben: I'll pass your message to nine.
19:29 lucasb left
nine laben: what makes you think that .map and .grep know how many elements they will process before they are done? 19:33
yoleaux 19:25Z <laben> nine: both map and grep return Seq, but couldn't the generated Seq already know its number of elems? after all .map applies to every item while .grep knows wheter an item passes the test and then gets included or not
nine laben: both do not return lists but Seq, i.e. an iterator. Only when some consumer (like HYPER) pulls values out of the iterator, the acutal mapping and grepping is performed 19:35
And all of this can happen on lazy or infinite lists.
19:37 zakharyas left
nine FROGGS: both me an moritz++ have looked at the $gorch issue. Sadly none of us has a good answer to what the most useful behavior should be. 19:37
FROGGS ahh 19:38
I am about making it act like on nom
laben nine: then the HYPER needs to begin the operations and only while running check the elem numbers / send the exceptions 19:41
19:42 ab6tract joined
nine laben: exactly! That's what I'm thinking when talking about refactoring. Sadly, we will have to save the elements of both lists to an IterationBuffer unless we know one or both to be lazy. 19:46
19:48 ChoHag left 19:49 muraiki joined
skids I do think using .elems to reify should be discouraged somehow, as later on we could have things find out .elems from chained Seqs which are not lazy, before work is performed. 19:50
But if that information is to be useful to optimizers, it might mean Seqs need to have introspection as to whether they are going to emit any Slips. 19:53
anyway, random thoughts I'll shut up now. 19:54
dalek rl6-roast-data: 8269141 | coke++ | / (10 files):
today (automated commit)
 19:59
[Coke] not sure why rakudo.jvm isn't running anywhere near as many tests as rakudo.moar 20:00
github.com/coke/perl6-roast-data/b..._rates.csv
colomon is suspicious that if you’re sending a Seq to hyper, something is already messed up.
[Coke] rakudo.moar-glr has 2463 failing tests out of 116528. 20:01
ab6tract notes that design.perl6.org/S02.html#The_Whatever_Object says that 'currying' is not the right way to talk about Whatever, but that seems to be how it is generally discussed 20:03
20:05 darutoko left 20:06 pullphinger joined, pullphinger left
raiph ab6tract: Here's how I might put it. Whatever is a completely generic "whatever". Even if a bunch of folk talked about the tasty curries they eat as "whatevers" doesn't mean other folk have to think "whatever" means a curry. 20:08
ab6tract also notes with some despair that 'orwith' is smashcased
20:09 bartolin joined
ab6tract raiph: I like it :D 20:09
raiph :)
20:10 pullphinger joined, pullphinger left, pullphinger joined, pullphinger left
raiph ab6tract: orwith is not the same as "or with", right? 20:11
ab6tract raiph: indeed. however, I would have hoped for 'or-with', I guess. But then, matching 'elsif' makes some sense there. 20:12
jdv79 how does one pay for spw
i didn't but it says i ddid 20:13
20:13 zakharyas joined
ab6tract I'm not sure that my fear of ending up with PHP-like degrees of inconsistency in the core setting is universally shared 20:13
[Coke] I have concerns about consistency, ab6tract. 20:14
ab6tract [Coke]: glad to hear it ain't just me :)
jdv79 they can be changed an deprecated later maybe 20:15
bike shedding wastes a lot of time
ab6tract jdv79: it would be nice to have that part wrapped before 6.0.0. bike shedding is not necessary if there is a simple rule to follow: kebab case, no abbreviations 20:16
otherwise, yes, it's all bike shedding
though no one wants to see min/max become minimum/maximum, I expect 20:17
20:17 xfix left
bartolin [Coke]: I think rakudo.moar runs a lot of NFG tests from S15-nfg which are not run on rakudo.jvm 20:19
[Coke] bartolin: oh, right. Thanks.
[Coke] commutes 20:21
raiph ab6tract: as I understand it the key is irclog.perlgeek.de/perl6/2015-03-25#i_10339632 20:22
20:24 zakharyas left
raiph ab6tract: because the point is to enable technically unconstrained evolution 20:27
20:29 KCL joined
raiph ab6tract: and not worry about getting it exactly right before you ship 20:29
20:31 KCL_ left 20:34 rindolf left
raiph (otoh, I've not seen anyone else say that, which is a tad disconcerting ;)) 20:34
skids I for one am a bit sick of dealing with released-too-early products at $DAYJOB, so I find it hard to jump on that bandwagon. 20:36
raiph s/exactly right before you ship/permanently linguistically "right"/ 20:37
skids Sure, there are degrees to that.
I think the proposed doc/rationale should be done pre-release to get people on the same page and as a hedge against any unnoticed glaring PAEs. 20:39
(and if we had that now I'd have less stupid questions for jnthn/TimToady) 20:40
raiph skids: do you mean Larry's "identity, identity, identity" thing? 20:41
skids No, there was a proposal for rearranging doc a bit and one of the new pages was "why some things are the way they are"
The design docs do go into some things pretty well, but you have to fish around in them. 20:44
raiph Ah. I was thinking of "why it matters a whole lot less than one might think that things are the way they are now", but I agree that's not helpful to those just trying to use what is available at any given time without interest in things improving 20:45
skids Well, from a user's standpoint (the non-naive user) you try to get a feel for the stability of a feature before using it, and if something has a good reason to be that way, it helps improve confidence. 20:47
skids very glad GLR is now on track. 20:48
raiph skids: well, consider whether orwith is spelled or-with or not; will that decision, or any other, get baked in to Perl 6 once 1.0 ships?
afaict the entire language is spectacularly malleable and that's perhaps its #1 long-term killer feature 20:50
skids I think the current spelling is correct, personally, both because I actually don't like kebab case and because I do not think else-if would be at all popular. But to the question, thos features that get use out of the gate are likely to get frozen that way.
20:50 silug joined
ab6tract inertia is inevitable, it's true 20:51
PerlJam I don't think anything will ever be "frozen". But there's a bit of pressure to get it right early-ish so that you don't have to carry so much backwards compatibility baggage with you into the future. 20:53
timotimo i wonder why literallytriggr suggested to give perl6 something built-in for constructing packets like tcp 20:55
raiph PerlJam: Agreed. Afaict the identity aspects of Perl 6 are designed to minimize the weight of decisions.
ab6tract and we should also be aware of the fact that "early-ish" is already "15 years in", as the outside world will perceive it 20:56
timotimo when other languages have sophisticated libraries to do that kind of thing
ab6tract there is a *lot* of pressure to have 6.0.0 as-right-as-possible. if we launch with all manner of smash,snake,and kebab case, some abbreviations here and other full names there.... 20:57
people will (rightfully, imo) have the opinion that the language is still half baked
(rightfully to perceive it, not rightfully considerable as half baked) 20:58
skids (Also, FWIW, despite the fact that kebab case got the nod (I'll have to deal) it is good that there is a convention, however, I do not think applying a convention like that to a foreign API is ever a good idea. For example, remapping all your C constants to kebab-case in a NativeCall mod would be silly.)
ab6tract skids: indeed. but that's not core, right?
skids Right, just a sidenote.
RabidGravy the thing is can you write software with it 21:00
well
ab6tract RabidGravy: is that the thing? because I don't need Perl 6 to write software. and no one else will buy that as a justification for using a language that after 15 years of development can manage to feel inconsistent 21:02
and that's the ultimate rub! the language is unbelievably consistent 21:03
it would only be a surface level, completely superficial naming convention level of inconsistency
skids Consistency does not have to be monolithic, just segmented and logically arranged.
ab6tract sure, but where is the rhyme or reason for why .uniq became .unique, but .substr isn't .substring ? 21:05
skids "Stuff we stole from C you already knew how to spell" 21:06
RabidGravy You've lost me. You're going into microscopic detail there. If you don't wamt people to make software using the language then fine. I'd go with stabilise.
ab6tract orwith/elsif has a stronger argument, to be sure
RabidGravy: my point is that Perl in general, and Perl 6 in particular, face an up hill battle in convincing programmers that they offer something significantly better 21:07
skids At least then, people can know that, hey, I'm picking up a bit of C when I learn this, too.
anyway, decommute.
21:07 skids left
ab6tract it's like making sure you comb your hair and wear shoes to a job interview 21:07
RabidGravy er 21:08
ab6tract or don't, but you can't be shocked when they laugh you out of the room
considering you had a decade and a half to get dressed 21:09
RabidGravy I've been doing that for thirty years
21:09 yqt joined
ab6tract I'm really not sure what we are discussing any more. Perl 6 has a chance to make a first impression. Why would we let surface level cosmetic issues get any traction in discussion, if we can avoid it? 21:10
21:13 diana_olhovik_ joined
RabidGravy that's lost me too 21:14
21:14 pmurias joined
pmurias We should have consistently named core methods/subs. 21:15
Having inconsistent names has no real benefit.
21:16 mr-foobar left
RabidGravy I'm going to say this only once, but Perl 6 has taken 15 years because no-one took it and ran with it in the first couple of years leaving open a space fore every next generation of CS graduate and bikeshedder to have their say. This is being fixed this year. 21:18
rangerprice RabidGravy: yes
ab6tract RabidGravy: well, inconsistent naming conventions sure will deliver the confidence that it is not a hodge podge of bike shedding... 21:21
(sarcasm)
RabidGravy fix it then :) 21:22
21:23 amurf joined
ab6tract RabidGravy: I've had my fill of sweeping PRs that go nowhere, thanks 21:25
rangerprice Is LWP module only available for Perl ?
21:27 amurf left
RabidGravy well we're working up HTTP::UserAgent to fill its boots but you know, contributions help 21:27
ab6tract I would gladly put in the work if it were commissioned in advance, but it's too much trouble to approach it without any certainty that it would get merged
anyway, I'm out for now
good *, all
21:27 ab6tract left
RabidGravy grumpy 21:28
what's the telll bot? 21:30
raiph .tell RabidGravy ... 21:32
yoleaux raiph: I'll pass your message to RabidGravy.
RabidGravy .tell ab6tract the touchstone of any language is whether you can write great software in it not whether the language is perfect. It's going to be great 21:34
yoleaux 21:32Z <raiph> RabidGravy: ...
RabidGravy: I'll pass your message to ab6tract.
RabidGravy raiph, cheers :)
21:36 muraiki left
RabidGravy see also PHP 21:37
21:38 diana_olhovik_ left
pmurias RabidGravy: you can write great software in really crappy languages 21:40
RabidGravy: you may have to suffer a lot to do it though 21:41
RabidGravy yes see PHP 21:42
but Perl 6 is a good language now, there's no point worrying to much in detail unless people fail to write good software with it :) 21:44
21:45 simcop2387 left
raiph .tell ab6tract I share your passion to get things right. If I upset you, that was the opposite of my intent and I apologize. 21:45
yoleaux raiph: I'll pass your message to ab6tract.
21:45 simcop2387 joined
laben .tell nine good that there is a plan forward for that, i guessed it would be something like that :) 21:46
yoleaux laben: I'll pass your message to nine.
laben good night|work #perl6 21:47
21:47 laben left
rangerprice i hope that Perl 6 don't lose the simplicity of Perl 5 21:47
RabidGravy It has all the simplicity and more consistency 21:48
21:55 cwDYKARN left, cwDYKARN_ left
RabidGravy sorry if I came over a bit humphy there but I think the aim is to make a language that you want to use, not necessarily one your CS professor would wet herself over 21:57
pmurias Perl 5 doesn't have that much simplicity 22:00
it has ease of use, but the language itself is pretty complex (with all the weird special cases)
22:01 lucasb joined
RabidGravy then it's broken and no one should use it ;-P 22:02
dalek p/js: f33f56a | (Pawel Murias)++ | src/vm/js/ (2 files):
Pass test 34.

Implement rxtype qastnode.
p/js: 2a7d1d8 | (Pawel Murias)++ | src/vm/js/bin/run_tests:
Add passing test 62 to run_tests.
22:03 nowan left
RabidGravy ;-P 22:03
pmurias RabidGravy: isn't that a pretty common opinion?
not in Perl 6 land 22:04
dwarring m: say $_ for ^3 22:05
GLRelia rakudo-moar d6049e: OUTPUT«0␤1␤2␤»
camelia rakudo-moar 815fff: OUTPUT«0␤1␤2␤»
dwarring m: say $_ for ^3.0
GLRelia rakudo-moar d6049e: OUTPUT«1␤2␤»
camelia rakudo-moar 815fff: OUTPUT«0␤1␤2␤»
dwarring noticed that in advent2009-day17.t
22:06 nowan joined
timotimo oh, whoops 22:06
that's interesting to say the least
probably a very simple thing to fix
want me to look at it, or want to do it yourself? :) 22:07
probably using .succ too early?
m: say $_ for "a".."f"
GLRelia rakudo-moar d6049e: OUTPUT«a␤b␤c␤d␤e␤f␤»
camelia rakudo-moar 815fff: OUTPUT«a␤b␤c␤d␤e␤f␤»
timotimo here it works though
dwarring timotimo: have a look
just seems to be Rats
timotimo m: say $_ for ^3.0e1 22:08
GLRelia rakudo-moar d6049e: OUTPUT«1␤2␤3␤4␤5␤6␤7␤8␤9␤10␤11␤12␤13␤14␤15␤16␤17␤18␤19␤20␤21␤22␤23␤24␤25␤26␤27␤28␤29␤»
camelia rakudo-moar 815fff: OUTPUT«0␤1␤2␤3␤4␤5␤6␤7␤8␤9␤10␤11␤12␤13␤14␤15␤16␤17␤18␤19␤20␤21␤22␤23␤24␤25␤26␤27␤28␤29␤»
timotimo Nums as well
lucasb m: say @ = 1.0^..3
GLRelia rakudo-moar d6049e: OUTPUT«3␤»
camelia rakudo-moar 815fff: OUTPUT«2 3␤»
dwarring erm and Nums 22:09
lucasb dwarring++ # funny bug
rangerprice Where can i find good reference to a book that explain how to create a programming language ?
22:11 mjgardner left
pmurias rangerprice: design a programming language or create an interpreter/compiler for one? 22:12
22:12 mjgardner joined
rangerprice pmurias: design a programming language 22:12
22:16 kaare_ left
pmurias I'm not aware of any such book 22:18
hoelzro if I have a sub foo, and I do my @a = 1, 2, foo(); does the return value from foo() flatten out into @a post-GLR? 22:19
timotimo grrrr
22:20 mr-foobar joined
timotimo i make changes to the optimizer and it causes rakudo to build a core setting that asplodes immediately after starting up 22:20
22:22 TEttinger joined
lizmat good *, #perl6 22:25
down to 154 failing test files, woot!
(for the glr of course)
[Coke] has travel booked most of the way to SPW now. whee.
colomon right still has to get train tickets. :) 22:27
s/right// 22:28
pmurias lizmat: re replacing use with yes/no for pragmas isn't the idea that pragmas are just modules with lower case names? 22:30
lizmat that's P5, why does P6 have to be that way ? :-) 22:31
22:32 smls_ joined, smls left
pmurias lizmat: what do we gain from it not being that way? 22:32
lizmat less IO during compilation 22:33
22:34 mjgardner left
lizmat the other thing is, that pragma's, I think, are typically versionless (or at least, hooked to a version of the system) 22:35
22:37 gagalicious joined
pmurias you mean the version of the pragma is determined by the the version of the language we use? 22:37
lizmat I would say so, yes 22:38
for the pragmas provided for by the system
dalek kudo/nom: 28faf19 | lizmat++ | src/core/IO/Path.pm:
Allow 0 as a valid file name in .IO

Re-imagined PR #508 by ugexe++		 22:40
pmurias lizmat: for me the module/pragma distinction seem really arbitrary
lizmat perhaps it is... we will figure it out :-) 22:42
ugexe for me it would be useful because i may want to turn off all pragmas without knowing what they are, ala `no pragmas` or something 22:43
pmurias ugexe: what would be the use of something like that? 22:45
22:46 skids joined
labster lizmat++ I was thinking of doing that last commit, but you beat me to it. 22:47
ugexe off the top of my head? i dunno, but it would be the same as anywhere you would use `no warnings` `no strict` in p5 except you dont have to remember them all 22:48
RabidGravy no 22:50
those things are only present in 5 because people don't fix their code 22:51
we don't have that burden
ugexe ive had plenty of valid reasons in perl5 to turn off warnings or strict or fatal. especially if you are testing things 22:52
RabidGravy oh I have, but let's say you can't to that in 6 22:54
22:54 leont joined
timotimo we have "no strict" 22:56
... or maybe i don't understand what you mean?
ugexe right. we have no strict, no fatal etc already. i was just suggesting a `no pragmas` to turn them all off 22:57
timotimo "no fatal" is the default outside of "try", isn't it?
RabidGravy but it's still compeled to crap out on type not found or my Int $a = "foo" 22:58
pointless
timotimo "crap out on type not found"? 22:59
RabidGravy m: my Foo $a; 23:00
camelia rakudo-moar 815fff: OUTPUT«5===SORRY!5===␤Type 'Foo' is not declared␤at /tmp/0WI4IaKrb2:1␤------> 3my Foo7⏏5 $a;␤Malformed my␤at /tmp/0WI4IaKrb2:1␤------> 3my7⏏5 Foo $a;␤␤»
GLRelia rakudo-moar d6049e: OUTPUT«5===SORRY!5===␤Type 'Foo' is not declared␤at /tmp/nVlHbSQBn7:1␤------> 3my Foo7⏏5 $a;␤Malformed my␤at /tmp/nVlHbSQBn7:1␤------> 3my7⏏5 Foo $a;␤␤»
timotimo yeah, but that's not "crapping out"
that's a compile-time error
RabidGravy pedant
timotimo are you playing devil's advocate right now or something? 23:01
timotimo is confused 23:02
RabidGravy possibly
23:02 yqt left
ugexe m: BEGIN no fatal; 23:03
GLRelia rakudo-moar d6049e: OUTPUT«===SORRY!===␤Cannot find method 'ann'␤»
camelia rakudo-moar 815fff: OUTPUT«===SORRY!===␤Cannot find method 'ann'␤»
RabidGravy "strictness" is within the coontrol of the programmer
what? 23:04
timotimo that's very redundant, as pragmas are *already* compile-time ... but the error is definitely LTA 23:05
lucasb m: BEGIN { no fatal } 23:07
GLRelia ( no output )
camelia ( no output )
ugexe if you want to control order better you can do tricks like that though 23:08
im not sure if that ordering works with pragmas though. i do it for modules at least
23:09 rurban left
pmurias ugexe: turning of a one specific pragma makes sense 23:11
ugexe: turning them all off with "no pragmas" makes zero sense to me
ugexe: if you don't remember what you are turning off you shouldn't do it
should we have a "use pragmas" that would turn all the pragmas on? 23:12
23:15 RabidGravy left
timotimo let's have a "use modules" that imports all modules the user has installed 23:17
arnsholt Heh. What could possibly go wrong!? =D
dalek p/js: fb0e205 | (Pawel Murias)++ | src/vm/js/QAST/Compiler.nqp:
Add a Chunk.void helper method for more concise definition of chunks that don't return a value.
 23:20
p/js: e365704 | (Pawel Murias)++ | src/vm/js/QAST/Compiler.nqp:
Avoid using ~ to concatenate Chunks
timotimo arnsholt: something different and exciting for every day of the week! 23:21
also "panda install Whatever" to install a random module
ugexe perl6 -M"no pragmas" some-script.pl6 23:22
that doesn't do anything, just demonstrates a use case 23:23
timotimo heh, a use case. 23:24
23:25 mjgardner joined
ugexe heh yea i clearly do not know what that means. i mean to say it is an example that makes sense to me 23:25
timotimo hm 23:26
do we have (or will we have) a use statement with multiple things to be used on the RHS?
23:28 lucasb left
timotimo having just seen a python script with an "import foo, bar, baz, quux, ..., ..., ..., ..., ..., ..., ..., ..., ..." line in it ... 23:29
ugexe use lib <a b c>; 23:31
cheating
timotimo that's not the right thing
TimToady well, where do you put the import list then?
timotimo TimToady: embrace the TTIAR fully :P
otherwise, a list of pairs could do 23:32
TimToady it seems to have more of a use case for classes than for modules, so it's easier to have 'need' take a list, since classes don't usually import 23:33
japhb TimToady: What day(s) are you and jnthn (and any other #perl6'ers) doing your talks? 23:36
TimToady I did my talk yesterday 23:37
jnthn is today
yesterday there was a talk by someone who tried rakudo/jvm, and was pleasantly surprised at all it could do, except for start up fast :) 23:38
timotimo oh, neato
lizmat 14:20 local time, 5:20 GMT if I'm not mistaken
I haven't seen any streams yet :-)
japhb can't wait for slide decks and recordings 23:39
Anyone happen to know what Matz is going to talk about? I saw him on the talks list and did a double take. 23:40
TimToady already talked about yesterday
timotimo japhb: "error while compiling. undeclared routine: wait"
TimToady something called 'streem' I gather
japhb Oh yeah, saw that on his github page with a bazillion stars 23:41
23:47 telex left 23:48 telex joined 23:49 leont left 23:59 davercc joined

Powered by Cro and the Raku® Programming Language.

Please report any issues / comments / feature requests as an issue on App::Raku::Log.

Thank you!