|
»ö« Welcome to Perl 6! | perl6.org/ | evalbot usage: 'perl6: say 3;' or rakudo:, niecza:, std:, or /msg p6eval perl6: ... | irclog: irc.perl6.org/ | UTF-8 is our friend! Set by sorear on 4 February 2011. |
|||
|
00:00
Chillance left
|
|||
| jlaire | p6: class C { method m() { <a b> } }; my @cs = C.new xx 3; say @cs.map({.m.list}).elems | 00:02 | |
| p6eval | pugs, rakudo d9fd17: OUTPUT«6» | ||
| ..niecza v17-2-gb8fcf85: OUTPUT«3» | |||
| jlaire | :/ | ||
|
00:03
eviltwin_b joined
|
|||
| jlaire | how to flatten a list of lists like that in niecza? | 00:03 | |
|
00:03
geekosaur left,
eviltwin_b is now known as geekosaur
00:06
dorlamm left
|
|||
| jlaire | found a workaround | 00:06 | |
|
00:17
eviltwin_b joined,
geekosaur left,
eviltwin_b is now known as geekosaur,
sisar joined
00:19
eviltwin_b joined,
geekosaur left,
eviltwin_b is now known as geekosaur
00:22
fgomez left
|
|||
| Radvendii | what's the proper way to undefine something? | 00:31 | |
|
00:31
fgomez joined
|
|||
| Radvendii | nom: my $a = null; | 00:32 | |
| p6eval | rakudo d9fd17: OUTPUT«===SORRY!===CHECK FAILED:Undefined routine '&null' called (line 1)» | ||
| Radvendii | nom: my $a = nil; | ||
| p6eval | rakudo d9fd17: OUTPUT«===SORRY!===CHECK FAILED:Undefined routine '&nil' called (line 1)» | ||
| Radvendii | nom: my $a.undef | ||
| p6eval | rakudo d9fd17: OUTPUT«===SORRY!===Confusedat /tmp/8SZTzdweWd:1» | ||
| idlecuriosity | nom: my $a = Nil; | 00:33 | |
| p6eval | rakudo d9fd17: ( no output ) | ||
| Radvendii | ah | ||
| thanks | |||
| idlecuriosity | np, I learnt it just now :) | ||
| Radvendii | hmm... that doesn't work for removing indicies of an array | 00:38 | |
| nom: my @a = 1,2,3; @a[1]=Nil; @a; | |||
| p6eval | rakudo d9fd17: ( no output ) | ||
| Radvendii | nom: my @a = 1,2,3; @a[1]=Nil; say @a; | ||
| p6eval | rakudo d9fd17: OUTPUT«1 3» | ||
| Radvendii | nom: my @a = 1,2,3; @a[1]=Nil; say @a.perl; | ||
| p6eval | rakudo d9fd17: OUTPUT«Array.new(1, Nil, 3)» | ||
| Radvendii | nom: my @a = 1,2,3; @a.delete(1); say @a.perl; | 00:39 | |
| p6eval | rakudo d9fd17: OUTPUT«Array.new(1, Any, 3)» | ||
| Radvendii | awww... really? | ||
| TimToady | are you trying to find splice()? | ||
| Radvendii | nom: my @a = 1,2,3; @a.splice(1); say @a.perl; | 00:40 | |
| p6eval | rakudo d9fd17: OUTPUT«Array.new(1)» | ||
| Radvendii | huh? | ||
| I don't know, what's it do? | |||
| jlaire | nom: my @a = <a b c d e f>; @a.splice(3); say @a.perl | 00:41 | |
| p6eval | rakudo d9fd17: OUTPUT«Array.new("a", "b", "c")» | ||
| Radvendii | I guess what i'm doing is simpler than i thought | ||
| sisar | Radvendii: here is splice in perl5 explained: szabgab.com/splice-to-slice-and-dic...-perl.html You can easily figure it out in perl6 :) | 00:42 | |
| Radvendii | i just want to clip off the last element of a list if it's Nil | ||
| that's easy enough | |||
| sorear | Radvendii: go read console_codes(4) or one of the 1e4 equivalent documents on the Web | 00:43 | |
| Radvendii | oh, is that for the clear screen thing? | 00:44 | |
| sorear | n: say <a b> xx 3 | ||
| p6eval | niecza v17-2-gb8fcf85: OUTPUT«a b a b a b» | ||
| sorear | Radvendii: clear screen, cursor positioning, colors, the workd | ||
| Radvendii | sweet! | 00:45 | |
| thanks | |||
|
00:57
icwiener left,
scott__ joined
01:01
replore_ joined
01:04
geekosaur left
01:05
geekosaur joined,
lestrrat left
01:06
lestrrat joined
01:10
tokuhirom left
01:11
eviltwin_b joined,
geekosaur left,
eviltwin_b is now known as geekosaur
01:16
sporous left,
replore_ left
01:17
eviltwin_b joined,
geekosaur left,
eviltwin_b is now known as geekosaur
01:21
sporous joined
01:34
raiph joined,
eviltwin_b joined,
geekosaur left
01:35
eviltwin_b is now known as geekosaur
01:38
scott___ joined
01:41
scott__ left
01:43
scott___ left
01:45
scott__ joined
01:48
geekosaur left,
eviltwin_b joined
01:49
eviltwin_b is now known as geekosaur
01:56
whiteknight left
01:59
geekosaur left,
eviltwin_b joined
02:00
eviltwin_b is now known as geekosaur
02:01
thou left
02:09
Radvendii left
02:10
eviltwin_b joined,
geekosaur left,
eviltwin_b is now known as geekosaur
02:21
geekosaur left,
eviltwin_b joined
02:22
eviltwin_b is now known as geekosaur
02:23
geekosaur left,
eviltwin_b joined
02:24
eviltwin_b is now known as geekosaur
02:32
geekosaur left
02:33
geekosaur joined
02:37
eviltwin_b joined,
geekosaur left,
eviltwin_b is now known as geekosaur
02:38
orafu left,
orafu joined
02:39
eviltwin_b joined,
geekosaur left,
sftp_ left,
eviltwin_b is now known as geekosaur
02:42
eviltwin_b joined,
geekosaur left,
eviltwin_b is now known as geekosaur
02:44
sftp joined
02:53
eviltwin_b joined,
geekosaur left,
eviltwin_b is now known as geekosaur
03:04
envi_ joined,
crab2313 joined
03:07
wolfman2000 joined
03:11
alvis` joined,
eviltwin_b joined,
geekosaur left,
eviltwin_b is now known as geekosaur
03:12
alvis left
03:15
alc joined
03:37
mikemol left
03:38
mmol_saffron joined
03:41
kaleem joined,
geekosaur left,
eviltwin_b joined,
eviltwin_b is now known as geekosaur
03:45
ponbiki joined
03:48
samurai2 joined
03:49
samurai2 left
03:52
alc left
03:56
geekosaur left
03:57
geekosaur joined
04:07
mmol_saffron left
04:26
crab2313 left
04:38
MContagious joined
04:48
alc joined
04:50
sisar left
04:56
alc left
05:03
thou joined
05:04
eviltwin_b joined,
geekosaur left,
eviltwin_b is now known as geekosaur
05:08
ponbiki left
05:10
alc joined
05:12
alc left
05:18
eviltwin_b joined,
geekosaur left
05:19
geekosaur joined
05:20
eviltwin_b left
05:21
eviltwin_b joined,
geekosaur left,
eviltwin_b is now known as geekosaur
05:23
fgomez left
05:30
eviltwin_b joined,
geekosaur left
05:31
eviltwin_b is now known as geekosaur
05:35
geekosaur left,
NamelessTee joined
05:37
geekosaur joined
05:48
eviltwin_b joined,
geekosaur left,
eviltwin_b is now known as geekosaur
06:06
eviltwin_b joined,
geekosaur left,
eviltwin_b is now known as geekosaur
06:07
NamelessTee left
06:15
wtw joined
06:17
sisar joined
06:18
sisar left,
sisar joined
06:19
eviltwin_b joined,
geekosaur left,
eviltwin_b is now known as geekosaur
06:21
eviltwin_b joined,
geekosaur left,
eviltwin_b is now known as geekosaur
06:31
geekosaur left,
eviltwin_b joined
06:32
geekosaur joined,
fhelmberger joined
06:35
eviltwin_b left,
snearch joined
06:38
geekosaur left
06:42
geekosaur joined
07:03
idlecuriosity left
07:04
snearch left
07:07
lestrrat left
07:09
lestrrat joined
07:16
xinming_ joined
07:19
xinming left
07:21
eviltwin_b joined,
geekosaur left
07:22
eviltwin_b is now known as geekosaur
|
|||
| moritz | \o | 07:39 | |
| jnthn: new problem: Pair isn't in BOOTSTRAP.pm, so I can't use Pair in Grammar.pm while compiling the setting :/ | 07:40 | ||
| jnthn: and traits.pm does 'use Perl6::BOOTSTRAP' | 07:41 | ||
| hm, I might special-case empty import lists | |||
|
07:50
thelazydeveloper joined
|
|||
| moritz | that way seems simpler anyway | 07:50 | |
|
08:14
fglock joined
|
|||
| jnthn | mornin' | 08:24 | |
| tadzik | hello | 08:25 | |
| jnthn | moritz: I don't think you should need import lists while compiling the setting. | ||
| It only does whatever the default thing is. | |||
| moritz | right | 08:26 | |
| jnthn: oh, and 'use Test :DEFAULT' produces DEFAULT => Mu | 08:30 | ||
| I guess it's the same bug as | |||
| r: sub f { return a => 5 }; say f.perl | 08:31 | ||
| p6eval | rakudo d9fd17: OUTPUT«"a" => Mu» | ||
|
08:31
fgomez joined
08:32
fgomez left,
fgomez joined
|
|||
| jnthn | Huh, it shouldn't be producing a named parameter at all... | 08:33 | |
| That's the point of looking at EXPR... | |||
| moritz | well, I think it creates a proper Pair | 08:34 | |
|
08:35
LylePerl left
|
|||
| moritz | nqp: sub f($x?) { say(nqp::defined($x)) }; f() | 08:43 | |
| p6eval | nqp: OUTPUT«Unrecognized nqp:: opcode 'nqp::defined' at line 1, near ") }; f()"current instr.: 'nqp;HLL;Grammar;panic' pc 22008 (src/stage2/gen/NQPHLL.pir:7047) (src/stage2/gen/NQPHLL.pm:329)» | ||
| moritz | nqp: sub f($x?) { say(pir::defined($x)) }; f() | ||
| p6eval | nqp: OUTPUT«0» | ||
| moritz | nqp: sub f($x?) { say(pir::defined($x)) }; f([]) | ||
| p6eval | nqp: OUTPUT«1» | ||
|
08:48
daxim joined
|
|||
| dalek | kudo/use-arglist: 6145974 | moritz++ | src/ (2 files): allow importing of tags the default is not imported when an explicit tag is provided |
08:55 | |
|
08:57
birdwindupbird joined
|
|||
| jnthn | yay :) | 09:01 | |
| tadzik | ooo | ||
| moritz | note that it currently does not complain about nonexisting tags | 09:02 | |
| so you can write | |||
| use Test :NONE; | |||
| though I think you can achieve the same with need Test; anyway | |||
| tadzik | and it won't import anything, right? | 09:03 | |
| jnthn | I'm not sure the spec says whether it should complain or not. | ||
| moritz | right | ||
| jnthn | At least, I don't recall S11 indicating as such. | ||
| moritz | jnthn: to me, importing looks more like a sub call than a method call, so by extension I think it should complain | ||
| jnthn | Hmm, I'd not thunk of it that way :) | 09:04 | |
| tadzik | ha, clever | 09:08 | |
|
09:09
geekosaur left
|
|||
| tadzik | although I see it more like obj.do_something_for_me than obj.?do_something_for_me | 09:09 | |
| so the conclusion is the same | |||
| jnthn | Note that there's various other bits of magic in arglist stuff. | ||
| moritz | well, TimToady++'s ruling was that importing calls a macro in the loaded module | 09:10 | |
| so until our macros are a bit more capable, we'll just do an approximation anyway | |||
| jnthn | Of note, :MANDATORY | 09:11 | |
|
09:11
geekosaur joined
|
|||
| jnthn | a...macro? | 09:11 | |
| moritz | yes | 09:12 | |
| because it has the option to do all the intersting stuff that aliasing routines can't do | |||
| like, adding a CATCH block | |||
| or tweaking slangs | |||
| and stuff like that | |||
| jnthn | ah | 09:13 | |
| Through COMPILING mostly, I guess. | |||
| moritz | yes | ||
| so no point in doing it now, since we don't hav e COMPILING | |||
| jnthn | Right | ||
| moritz | r: class A { sub f() is export { say 'oh shark' } }; import A; f | 09:14 | |
| p6eval | rakudo d9fd17: OUTPUT«===SORRY!===CHECK FAILED:Undefined routine '&f' called (line 1)» | ||
| jnthn | That doesn't work because we only install in UNIT::EXPORT so far, rather than through all the packages we're nested in. | 09:16 | |
| moritz | so export lists are per package right now? | 09:17 | |
| erm, sorry, per file? | |||
| jnthn | Yes, per compilation unit. | ||
| S11 says that in | |||
| class A { class B { sub foo() is export { } } } | 09:18 | ||
| It'd be installed in B::EXPORT::DEFAULT::<&foo>, A::EXPORT::DEFAULT::<&foo> and the UNIT one. | |||
| Today it only goes in UNIT | |||
| dalek | kudo/use-arglist: 3c393c6 | moritz++ | src/Perl6/ (2 files): refactor compile time evaluation into a World method |
09:19 | |
| kudo/use-arglist: 5b60299 | moritz++ | src/Perl6/Grammar.pm: fix import + arglist |
|||
|
09:20
eviltwin_b joined,
geekosaur left,
kresike joined
09:21
eviltwin_b is now known as geekosaur
|
|||
| moritz | meh, it seems that while not importing stuff works, importing custom tags still doesn't install the routines :/ | 09:24 | |
| but explicitly importing :DEFAULT or :ALL works | 09:25 | ||
| jnthn | Does exporting with tags other than the defautl one actually to the right instatllation? | ||
| moritz | I guess not | ||
| jnthn | r: sub foo() is export(:BLAH) { } | ||
| p6eval | rakudo d9fd17: ( no output ) | ||
| jnthn | I don't recall implementing that bit. | ||
| moritz | I wonder how it dispatches at all | 09:26 | |
| there's a multi trait_mod:<is>)(Routine:D \$r, :$export!) | 09:27 | ||
|
09:27
not_gerd joined
|
|||
| not_gerd | hello, #perl6 | 09:27 | |
| some benchmarking fun: gist.github.com/2626839 | |||
| moritz | \o not_gerd | ||
| not_gerd | the high-level code outperforms the low-level version ;) | 09:28 | |
| moritz | not_gerd: I think if you do subroutines with low-level types, you might be faster | ||
| not_gerd: because then rakudo can infer at compile time that there's a native num to pass | |||
| and no boxing will happen | |||
| jnthn | If you use native types in the wrong way, it will cost more due to loads of boxing/unboxing. | 09:29 | |
| moritz | r: multi trait_mod:<is>(Routine:D \$r, :$ext!, $args) { say $args.perl }; sub f is ex(:blah) { } | 09:30 | |
| p6eval | rakudo d9fd17: OUTPUT«===SORRY!===Cannot put required parameter after variadic parametersat /tmp/lI9rjYYKWy:1» | ||
| moritz | r: multi trait_mod:<is>(Routine:D \$r, $args, :$ext!) { say $args.perl }; sub f is ex(:blah) { } | ||
| p6eval | rakudo d9fd17: OUTPUT«===SORRY!===Cannot call 'trait_mod:<is>'; none of these signatures match::(Attribute:D $attr, :rw(:$rw)!):(Attribute:D $attr, :readonly(:$readonly)!):(Attribute:D $attr, :box_target(:$box_target)!):(Routine:D $r, :rw(:$rw)!):(Routine:D $r, :default(:$default)… | ||
| moritz | r: multi trait_mod:<is>(Routine:D \$r, $args, :$ext!) { say $args.perl }; sub f is ex('blah') { } | 09:31 | |
| jnthn | moritz: ex vs ext | ||
| p6eval | rakudo d9fd17: OUTPUT«===SORRY!===Cannot call 'trait_mod:<is>'; none of these signatures match::(Attribute:D $attr, :rw(:$rw)!):(Attribute:D $attr, :readonly(:$readonly)!):(Attribute:D $attr, :box_target(:$box_target)!):(Routine:D $r, :rw(:$rw)!):(Routine:D $r, :default(:$default)… | ||
| moritz | r: multi trait_mod:<is>(Routine:D \$r, $args, :$ex!) { say $args.perl }; sub f is ex('blah') { } | ||
| p6eval | rakudo d9fd17: OUTPUT«"blah"» | ||
| moritz | r: multi trait_mod:<is>(Routine:D \$r, $args, :$ex!) { say $args.perl }; sub f is ex(:blah) { } | ||
| p6eval | rakudo d9fd17: OUTPUT«===SORRY!===Cannot call 'trait_mod:<is>'; none of these signatures match::(Attribute:D $attr, :rw(:$rw)!):(Attribute:D $attr, :readonly(:$readonly)!):(Attribute:D $attr, :box_target(:$box_target)!):(Routine:D $r, :rw(:$rw)!):(Routine:D $r, :default(:$default)… | ||
| moritz | jnthn: thanks | ||
| r: multi trait_mod:<is>(Routine:D \$r, |$args, :$ex!) { say $args.perl }; sub f is ex(:blah) { } | |||
| p6eval | rakudo d9fd17: OUTPUT«Capture.new( list => ().list, hash => EnumMap.new("ex", 1, ))» | ||
| moritz | r: multi trait_mod:<is>(Routine:D \$r, *%args, :$ex!) { say %args.perl }; sub f is ex(:blah) { } | 09:32 | |
| p6eval | rakudo d9fd17: OUTPUT«===SORRY!===Required named parameter 'ex' not passed» | ||
| moritz | r: multi trait_mod:<is>(Routine:D \$r, :$ex!, *%args) { say %args.perl }; sub f is ex(:blah) { } | ||
| p6eval | rakudo d9fd17: OUTPUT«().hash» | ||
|
09:36
thou left,
eviltwin_b joined,
geekosaur left,
eviltwin_b is now known as geekosaur
|
|||
| moritz | r: class A { sub f is export(:YARR) { } }; say UNIT::EXPORT::.keys | 09:40 | |
| p6eval | rakudo d9fd17: OUTPUT«ALL DEFAULT» | ||
|
09:44
geekosaur left
09:45
geekosaur joined
|
|||
| arnsholt | .u ṛ | 09:46 | |
| phenny | U+1E5B LATIN SMALL LETTER R WITH DOT BELOW (ṛ) | ||
| arnsholt | .u ṝ | 09:47 | |
| phenny | U+1E5D LATIN SMALL LETTER R WITH DOT BELOW AND MACRON (ṝ) | ||
| arnsholt | .u ḷ | ||
| phenny | U+1E37 LATIN SMALL LETTER L WITH DOT BELOW (ḷ) | ||
| arnsholt | .u ḥ | ||
| phenny | U+1E25 LATIN SMALL LETTER H WITH DOT BELOW (ḥ) | ||
|
09:55
geekosaur left
09:56
geekosaur joined
|
|||
| moritz | jnthn: how do I access named arguments to a trait? | 09:58 | |
|
10:04
brrt joined,
eviltwin_b joined,
geekosaur left
10:05
eviltwin_b is now known as geekosaur
|
|||
| moritz | r: multi trait_mod:<is>(|$a) { say $a.perl }; sub f is foo(:bar) { } | 10:05 | |
| p6eval | rakudo d9fd17: OUTPUT«Capture.new( list => (sub f() { ... },).list, hash => EnumMap.new("foo", 1, ))» | ||
| moritz | no bar in sight :( | ||
| (pun intended) | |||
| tadzik | pun indented | 10:13 | |
| moritz | I guess the reason is that the argument list to the 'is' trait is parsed as a circumfix, which contains a semilist, not an arglist | 10:15 | |
| so there's no logic to handle named arguments | |||
| but, otoh, shouldn't named arguments then become simple pairs? | |||
| r: my $x = do { :foo }; say $x | |||
| p6eval | rakudo d9fd17: OUTPUT«"foo" => Bool::True» | ||
| moritz | r: my $x = (:foo) ; say $x | 10:16 | |
| p6eval | rakudo d9fd17: OUTPUT«"foo" => Bool::True» | ||
|
10:20
crab2313 joined,
crab2313 left
|
|||
| moritz | ok, importing by tag name works, though you have to set up the export package yourself :-) | 10:21 | |
| module A { our sub f is export(:YARR) { say 'oh shark' } } | 10:22 | ||
| UNIT::EXPORT::<YARR> := package YARR { our &f = &A::f; } | |||
| and then | |||
| use A :YARR; f; says 'oh shark' | |||
|
10:24
not_gerd left
10:28
cogno joined
10:35
cogno left
10:38
brrt left
10:44
JimmyZ joined
10:51
cogno joined
|
|||
| cogno | When one watches a commit page on github, how does he know what branch the commit belongs to? | 10:58 | |
| tadzik | I'm not sure if one does | 10:59 | |
| cogno | Too bad. | 11:00 | |
| tadzik | any particular commit you have in mind? | 11:03 | |
|
11:06
brrt joined
11:10
snearch joined,
moritz joined
11:11
cogno left
|
|||
| jnthn | moritz: I suspect you've found a bug in the handling or args to the trait mod. | 11:15 | |
|
11:17
_Vi joined
|
|||
| _Vi | Is Perl6 ready for use cases like "perl -pe 's/something/anything/' -i *.c", but with per6'th numerous regex enhancements? | 11:19 | |
|
11:19
tyatpi joined
11:21
cogno joined
11:26
cogno left
|
|||
| tadzik | I don't think we have -i implemented | 11:27 | |
| brrt | would it be possible - and if so, useful - to create a subset Filename of String where the file exists? | 11:28 | |
|
11:28
lestrrat left
|
|||
| tadzik | possible? I think so | 11:29 | |
|
11:29
lestrrat joined
|
|||
| tadzik | r: subset Filename of Str where { .IO ~~ :e } | 11:30 | |
| p6eval | rakudo d9fd17: ( no output ) | ||
| jnthn | r: subset Filename of Str where { .IO ~~ :e }; say 'README' ~~ Filename; say 'lolno' ~~ Filename | ||
| p6eval | rakudo d9fd17: OUTPUT«FalseFalse» | ||
| tadzik | r: subset Filename of Str where { .IO ~~ :e }; Filename $a = "README" | ||
| p6eval | rakudo d9fd17: OUTPUT«===SORRY!===Confusedat /tmp/s24cf4g888:1» | ||
| jnthn | r: subset Filename of Str where { .IO ~~ :e }; say 'perl6' ~~ Filename; say 'lolno' ~~ Filename | ||
| p6eval | rakudo d9fd17: OUTPUT«FalseFalse» | ||
| tadzik | r: subset Filename of Str where { .IO ~~ :e }; my Filename $a = "README" | ||
| p6eval | rakudo d9fd17: OUTPUT«Type check failed in assignment to '$a'; expected 'Filename' but got 'Str' in block <anon> at /tmp/i_JnSSyRX1:1» | ||
| jnthn | r: say "README".IO ~~ :e | 11:31 | |
| p6eval | rakudo d9fd17: OUTPUT«False» | ||
| jnthn | r: say "README" ~~ :e | ||
| p6eval | rakudo d9fd17: OUTPUT«Method 'e' not found for invocant of class 'Str' in method ACCEPTS at src/gen/CORE.setting:5639 in block <anon> at /tmp/Q58SGxK3SP:1» | ||
| moritz | brrt: note that type checks are supposed to pure functions | ||
| brrt: so if somebody adds or deletes a file while your program is running, that might cause some havoc | 11:32 | ||
| brrt | dangerous method | 11:33 | |
| but still | |||
|
11:34
geekosaur left
11:36
geekosaur joined
11:45
noam left
11:46
noam joined
|
|||
| _Vi | Is (will be) Perl6 in general as good tool for ad-hoc oneliners as Perl5 is? It would be good to be able to use it as "enhanced sed" with advanced Unicode capabilities. | 11:46 | |
|
11:46
noam left,
noam joined
|
|||
| moritz | _Vi: we haven't reached that level yet, but we certainly intend to do it | 11:47 | |
| I've been implementing a few command line options these past weeks, maybe I should consider doing some more in the -F or -i direction | 11:48 | ||
| afk& | |||
| _Vi | (In my head the "soul and spirit of Perl" lies in oneliners and short non-modular text-processing scripts. Perl6 does not have this spirit yet.) | ||
| dalek | rlito: 6244c95 | (Flavio S. Glock)++ | t5/op/exp.t: Perlito5 - add t/op/exp.t |
11:53 | |
|
11:57
brrt left
11:58
_sri joined,
skids left,
moritz left
11:59
moritz joined
12:05
_Vi left
12:06
mtk joined
12:31
MContagious left
12:34
geekosaur left,
eviltwin_b joined,
eviltwin_b is now known as geekosaur
12:48
eviltwin_b joined,
geekosaur left,
eviltwin_b is now known as geekosaur
12:50
PacoAir joined,
eviltwin_b joined,
geekosaur left
12:51
eviltwin_b is now known as geekosaur
12:52
geekosaur left,
geekosaur joined
12:53
snearch left
12:55
PacoAir left
13:04
bluescreen10 joined,
PacoAir_ joined
13:06
eviltwin_b joined,
geekosaur left,
eviltwin_b is now known as geekosaur
13:07
_Vi joined
13:08
bluescreen10 left
13:10
Guest51792 left,
eviltwin_b joined,
geekosaur left
13:11
eviltwin_b is now known as geekosaur
13:13
eviltwin_b joined,
geekosaur left
13:14
bluescreen10 joined,
geekosaur joined
13:15
xenu joined,
xenu is now known as Guest71264
13:17
eviltwin_b left
13:24
bluescreen10 left
13:25
skids joined,
bluescreen10 joined
13:31
eviltwin_b joined,
geekosaur left
13:32
eviltwin_b is now known as geekosaur
13:36
tyatpi left
13:40
mynameisbrian joined
13:43
pernatiy left
13:45
araujo left
13:46
araujo joined,
pernatiy joined,
pernatiy left
13:48
pernatiy joined
13:49
tyatpi joined
|
|||
| colomon | n: say '\S\' | 13:51 | |
| p6eval | niecza v17-2-gb8fcf85: OUTPUT«===SORRY!===Unsupported use of bare 'say'; in Perl 6 please use .say if you meant $_, or use an explicit invocant or argument at /tmp/BSnyHC3wCm line 1:------> say⏏ '\S\'Confused at /tmp/BSnyHC3wCm line 1:------> … | ||
| colomon | n: say 'A'.ord | 13:52 | |
| p6eval | niecza v17-2-gb8fcf85: OUTPUT«65» | ||
|
13:54
pernatiy_ joined,
pernatiy left
|
|||
| colomon | what's the p6 equivalent of $' ? | 13:54 | |
|
13:55
kaleem left
|
|||
| colomon | ah, $/.postmatch | 13:57 | |
|
13:59
DarthGandalf joined,
eviltwin_b joined,
geekosaur left
14:00
eviltwin_b is now known as geekosaur
|
|||
| colomon | n: say "face".hex | 14:00 | |
| p6eval | niecza v17-2-gb8fcf85: OUTPUT«Unhandled exception: Unable to resolve method hex in class Str at /tmp/r3CZD0vf4z line 1 (mainline @ 2)  at /home/p6eval/niecza/lib/CORE.setting line 3840 (ANON @ 3)  at /home/p6eval/niecza/lib/CORE.setting line 3841 (module-CORE @ 65)  at /home/p6e… | ||
|
14:00
mynameisbrian left
|
|||
| colomon | r: say "face".hex | 14:00 | |
| p6eval | rakudo d9fd17: OUTPUT«Method 'hex' not found for invocant of class 'Str' in block <anon> at /tmp/tC9Oi3Rs_h:1» | ||
| colomon 's brain is starting to hurt from switching back and forth with p5 | 14:01 | ||
| jnthn | r: say :16('face') | ||
| p6eval | rakudo d9fd17: OUTPUT«64206» | ||
| colomon | r: my $a = 'face'; say :16($a) | ||
| p6eval | rakudo d9fd17: OUTPUT«64206» | ||
| colomon | n: my $a = 'face'; say :16($a) | ||
| p6eval | niecza v17-2-gb8fcf85: OUTPUT«64206» | ||
| colomon | jnthn++ | 14:02 | |
|
14:03
eviltwin_b joined,
geekosaur left,
eviltwin_b is now known as geekosaur
14:04
kaare_ joined
14:09
Guest71264 left
14:14
xenu joined
14:15
xenu is now known as Guest66045
14:23
eviltwin_b joined,
geekosaur left,
eviltwin_b is now known as geekosaur,
tyatpi left
14:28
kresike left
14:31
PacoAir_ left
14:33
cognominal joined
14:34
cognominal___ left
14:37
tyatpi joined,
sporous left,
sporous joined
14:39
araujo left,
eviltwin_b joined,
geekosaur left
14:40
eviltwin_b is now known as geekosaur,
araujo joined
14:41
eviltwin_b joined,
geekosaur left
14:42
eviltwin_b is now known as geekosaur
14:47
eviltwin_b joined,
geekosaur left,
eviltwin_b is now known as geekosaur
14:51
Kresike joined
14:53
eviltwin_b joined,
geekosaur left
14:54
eviltwin_b is now known as geekosaur
14:55
zby_home_ joined
14:57
fgomez left
14:59
birdwindupbird left
15:01
erkan left
15:05
geekosaur left,
eviltwin_b joined,
eviltwin_b is now known as geekosaur
15:12
tyatpi left,
eviltwin_b joined,
geekosaur left
15:13
eviltwin_b is now known as geekosaur
15:23
glass left
15:24
envi_ left
15:25
envi_ joined
15:26
sftp left
15:27
sftp joined
15:28
tyatpi joined,
Guest66045 left,
tokuhirom joined
15:29
carlin joined
15:30
envi_ left
|
|||
| masak | lol shark hai, #perl6 | 15:30 | |
| jnthn | fin evening, masak | 15:32 | |
|
15:32
envi_ joined
|
|||
| moritz | \o | 15:33 | |
|
15:35
fglock left
|
|||
| masak .oO( have the appropriate amount of fin ) | 15:35 | ||
|
15:35
fgomez joined
15:36
MContagious joined
15:38
xenu joined,
xenu is now known as Guest74228
15:40
fgomez left
15:49
JimmyZ left,
Psyche^ joined
|
|||
| moritz | fin ack | 15:49 | |
| masak .oO( NAK on wood ) | 15:50 | ||
| geekosaur too NAKered | 15:51 | ||
| moritz | no details please | 15:52 | |
|
15:53
Patterner left,
Psyche^ is now known as Patterner
15:56
geekosaur left,
eviltwin_b joined,
eviltwin_b is now known as geekosaur
16:09
geekosaur left
|
|||
| raiph | p6: say lines("asdf")[0] # expected this to look for a file "asdf" and say its first line | 16:13 | |
| p6eval | pugs: OUTPUT«*** No such subroutine: "&lines" at /tmp/iNzpLXdSwX line 1, column 5 - line 2, column 1» | ||
| ..rakudo d9fd17, niecza v17-2-gb8fcf85: OUTPUT«asdf» | |||
| jnthn | raiph: That's slept lines("asdf".IO)[0] | ||
| raiph | thx jnthn | 16:14 | |
| moritz | r: say lines("asdf".IO)[0] | ||
| p6eval | rakudo d9fd17: OUTPUT«Unable to open filehandle from path 'asdf' in method open at src/gen/CORE.setting:6588 in method get at src/gen/CORE.setting:6608 in code <anon> at src/gen/CORE.setting:6632 in sub coro at src/gen/CORE.setting:4926 in method reify at src/gen/CORE.setting:… | ||
| TimToady | p6: say words('the quick brown fox jumped')[3] | ||
| p6eval | rakudo d9fd17: OUTPUT«===SORRY!===CHECK FAILED:Undefined routine '&words' called (line 1)» | ||
| ..pugs: OUTPUT«*** No such subroutine: "&words" at /tmp/gtj1gJE0m_ line 1, column 5 - line 2, column 1» | |||
| ..niecza v17-2-gb8fcf85: OUTPUT«===SORRY!===Undeclared routine: 'words' used at line 1Unhandled exception: Check failed at /home/p6eval/niecza/boot/lib/CORE.setting line 1364 (die @ 3)  at /home/p6eval/niecza/src/STD.pm6 line 1147 (P6.comp_unit @ 33)  at /hom… | |||
| jnthn | .oO( I'm not sure if that typo was ironic or Freudian... ) |
16:15 | |
| bbkr | wow, awesome trick with "file".IO | ||
| raiph | right. (btw i like your spelling of spelled) | ||
|
16:15
geekosaur joined
|
|||
| TimToady | p6: say 'the quick brown fox jumped'.words[3] | 16:17 | |
| p6eval | rakudo d9fd17, niecza v17-2-gb8fcf85: OUTPUT«fox» | ||
| ..pugs: OUTPUT«*** No such method in class Str: "&words" at /tmp/7Jvqdl04jT line 1, column 5 - line 2, column 1» | |||
| TimToady | multi method words ( Str $input: Int $limit = Inf --> List ) is export | ||
| supposed to be exported as as a function | |||
|
16:18
fglock joined,
fgomez joined
|
|||
| masak | TimToady: could we get 'invert' as a function, too? I'd find that useful. | 16:18 | |
|
16:19
geekosaur left,
geekosaur joined
|
|||
| TimToady | sure, anything that makes sense both ways and is common enough for it to matter should be considered for export at least | 16:20 | |
| masak | \o/ | ||
| oh oh | |||
| TimToady | but I'm sure there are methods that are going to be rare enough that they don't merit such treatement | 16:21 | |
| masak | and List.invert (as being the same as List.kv.hash.invert) -- I'd like that too | ||
| TimToady | um | ||
| why not List.pairs.invert? | |||
| .kv is a micro-smell | |||
| masak | ah. | 16:22 | |
|
16:22
MContagious left
|
|||
| masak | yeah. maybe that's enough, then. | 16:22 | |
| p6: say <a b c>.pairs.invert | |||
| p6eval | pugs: OUTPUT«*** Not a keyed value: VList [VStr "a",VStr "b",VStr "c"] at /tmp/IrcXokCCwJ line 1, column 5 - line 2, column 1» | ||
| ..niecza v17-2-gb8fcf85: OUTPUT«Unhandled exception: Unable to resolve method invert in class List at /tmp/hLf2h_qa2Z line 1 (mainline @ 3)  at /home/p6eval/niecza/lib/CORE.setting line 3840 (ANON @ 3)  at /home/p6eval/niecza/lib/CORE.setting line 3841 (module-CORE @ 65)  at /home… | |||
| ..rakudo d9fd17: OUTPUT«Method 'invert' not found for invocant of class 'List' in block <anon> at /tmp/9lmAS5IB4E:1» | |||
| TimToady | mind, I dunno if that even works | ||
| masak | seems not :) | ||
| TimToady | but we ought to be able to write one that doesn't need an intermediate hash, meseemeth | 16:23 | |
| that is, a List.invert that assumes pairs the same way a hash initializer does | 16:25 | ||
| masak | right. | ||
| I keep finding myself in situations when I want that. | |||
| TimToady | then it doesn't matter whether whether you .kv or .pairs | ||
| masak | :) | ||
| TimToady | but it would require one or the other to introduce the .keys | 16:26 | |
|
16:26
fglock left
|
|||
| TimToady | it might be a little surprising to someone who expects @array.invert to behave exactly like @hash.invert though | 16:28 | |
| sorear | good * #perl6 | 16:29 | |
| TimToady | \o | ||
|
16:29
thou joined
|
|||
| jnthn | masak: Curious - what kind of situation? | 16:29 | |
|
16:31
ponbiki joined
|
|||
| TimToady | emulating content-addressable memory | 16:31 | |
|
16:31
eviltwin_b joined,
geekosaur left
|
|||
| masak | jnthn: hex puzzle. mapping forwards from j2-like coords to 1-d board indices, and then backwards to 2-d coordinate pairs. | 16:31 | |
|
16:31
eviltwin_b is now known as geekosaur
16:32
wtw left
|
|||
| jnthn | ah, ok | 16:32 | |
| masak | jnthn: the forwards mapping is done most easily as 'my %horizontals = <i1 i2 ...>.kv.hash.invert' | ||
| TimToady | basically, any 2-way mapping where one of them is naturally positional | 16:34 | |
|
16:34
mspaulding joined
|
|||
| masak | right. | 16:34 | |
|
16:34
mspaulding left
16:35
wolfman2000 left
|
|||
| sisar | um, installing LWP::Simple fails for me with failure in dependence resolution: gist.github.com/2628829. | 16:36 | |
| TimToady | I could probably be argued into List.invert assuming it should invert on the indexes, and leave out the hashlist stuff | ||
|
16:36
NamelessTee joined
|
|||
| TimToady | while less powerful, it's probably more POLS | 16:37 | |
| the other way is to distinguish Array.invert from List.invert, but that bothers me | |||
| masak | oh, I meant inverting on the indices. | 16:38 | |
| sisar: panda seems to complain because the URI tests don't pass -- so it doesn't go on and install LWP::Simple. | 16:39 | ||
| TimToady | perl6: say (a => 42).invert.perl | ||
| p6eval | rakudo d9fd17, niecza v17-2-gb8fcf85: OUTPUT«42 => "a"» | ||
| ..pugs: OUTPUT«*** No such method in class Pair: "&invert" at /tmp/ifgTGz1xwR line 1, column 5 - line 2, column 1» | |||
| TimToady | we can always hyperinvert a pairlist | ||
| masak | that still doesn't feel Huffmanized enough to me. | 16:40 | |
| TimToady | I mean that in addition to List.invert | ||
| masak | ah. | 16:41 | |
| TimToady | because that would do the wrong thing with a list of pairs | ||
| sisar | masak: ok. So I need to wait till URI is fixed ? (i know, i should fix it myself) | ||
| :) | 16:42 | ||
| TimToady | you'd end up with 0 => (a => 42) | ||
| perl6: my %hash = (:a(1), :b(2), :c(3)).pairs».invert; say %hash<c> | 16:43 | ||
| p6eval | pugs: OUTPUT«*** Not a keyed value: VList [VRef <Pair:0xf6d85bb9>,VRef <Pair:0xf6d85c31>,VRef <Pair:0xf6d85c8d>] at /tmp/bzrU0kk1FC line 1, column 12-47» | ||
| ..rakudo d9fd17, niecza v17-2-gb8fcf85: OUTPUT«Any()» | |||
| TimToady | oops | ||
| perl6: my %hash = (:a(1), :b(2), :c(3))».invert; say %hash<c> | 16:44 | ||
| p6eval | pugs: OUTPUT«*** No such method in class Array: "&>>invert" at /tmp/eZZ5NPmqIS line 1, column 12-41» | ||
| ..rakudo d9fd17, niecza v17-2-gb8fcf85: OUTPUT«Any()» | |||
|
16:44
libertyprime left
|
|||
| masak | sisar: yes, please do. or at least figure out more about the test failures. | 16:44 | |
| sisar | ok | ||
| TimToady | perl6: my %hash = <a b c d e>.pairs».invert; say %hash<c> | ||
| p6eval | rakudo d9fd17, niecza v17-2-gb8fcf85: OUTPUT«2» | ||
| ..pugs: OUTPUT«*** Not a keyed value: VList [VStr "a",VStr "b",VStr "c",VStr "d",VStr "e"] at /tmp/2FMJ66De4g line 1, column 12-37» | |||
| TimToady | that at least avoids creating a temp hash | 16:45 | |
|
16:45
libertyprime joined
16:48
eviltwin_b joined,
geekosaur left
16:49
eviltwin_b is now known as geekosaur
16:55
erkan joined,
erkan left,
erkan joined
|
|||
| masak | perl6: my %hash = <a b c d e> Z=> 0..*; say %hash<c> | 16:55 | |
| p6eval | rakudo d9fd17, niecza v17-2-gb8fcf85: OUTPUT«2» | ||
| ..pugs: OUTPUT«*** unknown parse error at /tmp/sxmYSABSen line 1, column 27» | |||
| masak | so does this. but I don't much like the end weight of it. | ||
|
16:55
eviltwin_b joined,
geekosaur left
16:56
eviltwin_b is now known as geekosaur
|
|||
| masak | that's why I'd like a sub form of 'invert', too. because it places the transformation up front. | 16:57 | |
|
16:58
geekosaur left,
geekosaur joined
|
|||
| sorear | p6: &invert | 16:59 | |
| p6eval | pugs: OUTPUT«***  Unexpected end of input expecting "::" or signature value Variable "&invert" requires predeclaration or explicit package name at /tmp/3ubh2sCbl8 line 1, column 8» | ||
| ..rakudo d9fd17, niecza v17-2-gb8fcf85: ( no output ) | |||
| sorear | n: say invert [<a i u e o>] | 17:00 | |
| p6eval | niecza v17-2-gb8fcf85: OUTPUT«Unhandled exception: Nominal type check failed in binding '%h' in 'invert'; got Array, needed Associative at /home/p6eval/niecza/lib/CORE.setting line 0 (invert @ 1)  at /tmp/OFg3FW4C_I line 1 (mainline @ 2)  at /home/p6eval/niecza/lib/CORE.setting li… | ||
| sorear | n: say invert {<a i u e o> Z=> 0..*} | ||
| p6eval | niecza v17-2-gb8fcf85: OUTPUT«Unhandled exception: Nominal type check failed in binding '%h' in 'invert'; got Block, needed Associative at /home/p6eval/niecza/lib/CORE.setting line 0 (invert @ 1)  at /tmp/rU3cw1ymAB line 1 (mainline @ 2)  at /home/p6eval/niecza/lib/CORE.setting li… | ||
| sorear | n: say invert {%(), <a i u e o> Z=> 0..*} | ||
| p6eval | niecza v17-2-gb8fcf85: OUTPUT«Unhandled exception: Nominal type check failed in binding '%h' in 'invert'; got Block, needed Associative at /home/p6eval/niecza/lib/CORE.setting line 0 (invert @ 1)  at /tmp/FvJjCHG074 line 1 (mainline @ 2)  at /home/p6eval/niecza/lib/CORE.setting li… | ||
| sorear | n: say invert %(<a i u e o> Z=> 0..*) | ||
| p6eval | niecza v17-2-gb8fcf85: OUTPUT«0 => "a" 1 => "i" 2 => "u" 3 => "e" 4 => "o"» | 17:01 | |
| masak | \o/ | 17:02 | |
|
17:02
vlixes joined
|
|||
| masak | any good reason *not* to make 'invert <a i u e o>' work, too? | 17:02 | |
|
17:04
PacoAir joined
|
|||
| TimToady | I already said I was fine with that part, I think...my wonderings were more about the types involved | 17:04 | |
|
17:06
carlin left,
eviltwin_b joined,
geekosaur left
17:07
carlin joined,
eviltwin_b is now known as geekosaur
|
|||
| tadzik | 'afternoon, #eplr6 | 17:07 | |
| or whatever channel I'm on | |||
|
17:10
simcop2387 joined
17:11
Chillance joined
|
|||
| Woodi | hallo | 17:12 | |
| perl6: my %hash = (:a(1), :b(2), :c(3)); say %hash | |||
| p6eval | niecza v17-2-gb8fcf85: OUTPUT«{"a" => 1, "b" => 2, "c" => 3}» | ||
| ..rakudo d9fd17: OUTPUT«("a" => 1, "b" => 2, "c" => 3).hash» | |||
| ..pugs: OUTPUT«a 1b 2c 3» | |||
| masak .oO( Perl 6 was delayed many years, because the community members kept logging into anagrams of the channel name ) | 17:13 | ||
| Woodi | it's strange that compilers have different output... | ||
| masak | Woodi: no, it's not. | ||
| Woodi: .gist defaults to .perl, which is compiler-dependent. | |||
| Woodi | ah, right. so "internal dumper" is standarized ? | 17:14 | |
| I think about it as kind of code serialization... for RPC or something... | 17:15 | ||
|
17:19
Guest74228 left
17:26
geekosaur left,
eviltwin_b joined,
eviltwin_b is now known as geekosaur
17:34
geekosaur left,
eviltwin_b joined,
eviltwin_b is now known as geekosaur
17:35
ocharles joined
17:40
xenu joined,
eviltwin_b joined,
geekosaur left
17:41
xenu is now known as Guest40378,
eviltwin_b is now known as geekosaur
17:42
not_gerd joined
|
|||
| not_gerd | hello, #perl6 | 17:42 | |
| google fail - is it possible to define your own ternary operators? | |||
|
17:42
geekosaur is now known as allbery_b
17:45
geekosaur joined
|
|||
| moritz | not yet, i fear | 17:45 | |
|
17:46
eviltwin_b joined,
geekosaur left
17:47
geekosaur joined
|
|||
| masak | what's missing? | 17:48 | |
| jnthn | Something that does the right thing with the definition, I suspect. | ||
| masak | r: sub infix:<!? !?>($a, $b, $c) { "$a, $b and $c went into a bar..." }; say 1 !? 2 !? 3 | ||
| p6eval | rakudo d9fd17: OUTPUT«===SORRY!===Confusedat /tmp/rLuIegwVIH:1» | ||
| masak | aww | ||
| moritz | ttiar | 17:49 | |
| hm, no | |||
| moritz can't parse | |||
| masak | ;) | ||
| moritz | r: sub infix:<FOO BAR>(*@a) { say @a.perl }; 1 FOO 2 BAR 3 | ||
| p6eval | rakudo d9fd17: OUTPUT«===SORRY!===Confusedat /tmp/UU5finyUCs:1» | ||
|
17:49
allbery_b left
|
|||
| moritz | r: sub infix:<FOO BAR>(*@a) { say @a.perl }; 1 FOO BAR 3 | 17:49 | |
| p6eval | rakudo d9fd17: OUTPUT«Array.new(1, 3)» | ||
| moritz | r: sub infix:<FOO BAR>(*@a) { say @a.perl }; 1 FOO BAR 3 | 17:50 | |
| p6eval | rakudo d9fd17: OUTPUT«===SORRY!===Confusedat /tmp/qHyav8EPpc:1» | ||
| not_gerd | anyway, I had some more fun with the n-body benchmark | ||
| if anyone wants to take a look: gist.github.com/2626839 | |||
| jnthn | moritz: Heh. Was just glancing the code and realized...it just...installs the token, including the space. :) | 17:51 | |
| moritz | jnthn: I figured :-) | 17:52 | |
| jnthn | I'm gonna redo that whole load of stuff soonish anyways. | 17:53 | |
|
17:53
geekosaur left
|
|||
| jnthn | To fix the serialization issues, and also to enable the precedence traits. | 17:53 | |
| tadzik | jnthn: did you have any chance to look at that non-deterministic precompilation fun? | 17:54 | |
| [Coke] | jnthn: are you using win xp or win 7? | 17:55 | |
| jnthn | tadzik: There was a non-deterministic one? | ||
| [Coke]: Win 7. | |||
| tadzik | jnthn: yeah, URI and panda suffer from it. Basically, loading sometimes fails with "No object at STable <n>", and sometimes not | ||
| jlaire | .u ’ | ||
| phenny | U+2019 RIGHT SINGLE QUOTATION MARK (’) | ||
| jnthn | tadzik: "sometimes"? :/ | 17:56 | |
| tadzik | jnthn: yeah, that's the point :/ | ||
| jnthn: I can provide a shell if you can't reproduce | |||
| jnthn | What do you have to do to make it suceed? Just run it again? Or re-compile? | 17:57 | |
|
17:57
eviltwin_b is now known as geekosaur
|
|||
| tadzik | jnthn: you have a 50% chance. Recompilation triggers it | 17:57 | |
| if it's compiled with luck, then it always works | |||
| if without luck, then it never does | |||
| afair, will recheck | |||
| jnthn: yes, it's a matter of recompiling it | 18:00 | ||
|
18:03
tokuhirom left,
tokuhirom joined
18:07
pernatiy_ left
18:08
pernatiy joined,
tokuhirom left
18:10
alester joined
|
|||
| masak | tadzik: so that makes it deterministic, then? | 18:23 | |
|
18:28
wolfman2000 joined
|
|||
| tadzik | no | 18:28 | |
| you have approx. 50% chance it'd work | 18:29 | ||
| masak | :/ | ||
| grep the code for any 1d2 die rolls... | 18:30 | ||
|
18:30
eviltwin_b joined,
geekosaur left
18:31
eviltwin_b is now known as geekosaur
18:33
zby_home_ left
|
|||
| tadzik | my only guess is the Parrot's hash randomization | 18:37 | |
| I know of no other things that are random | |||
|
18:37
fhelmberger left
|
|||
| TimToady | parallel make could be random | 18:47 | |
| jnthn | Ah | 18:48 | |
| And parallel make would potentially cause issues like this... | |||
|
18:52
wolf2k_away joined
18:55
wolfman2000 left
|
|||
| sisar | tadzik: now i remember, i got the exact same error "No STable at index 8" when compiling panda today. Any info I can provide? I still have the terminal output of that try. | 18:57 | |
|
18:57
_Vi left
|
|||
| Celelibi | About the >> and << metaoperators: what is an operator? | 18:59 | |
| masak | Celelibi: how do you mean? | ||
| an operator is anything that S03 talks about. to a first approximation :P | |||
| Celelibi | How can I make my own operator to put between >> and << ? | ||
| masak | Celelibi: just define it, as a sub. | 19:00 | |
| colomon | Celelibi: sub infix:<whatever>($a, $b) { ... } | ||
| masak | r: sub infix:<!!!>($a, $b) { "A $a and a $b walk into a bar..." }; say "platypus" !!! "philosopher" | ||
| p6eval | rakudo d9fd17: OUTPUT«A platypus and a philosopher walk into a bar...» | ||
| Celelibi | What are they talking about ? | 19:01 | |
| :) | |||
| masak | Plato :) | ||
| colomon | n: sub infix:<whatever>($a, $b) { $a ~ " blue" x $b }; say <go blue> >>whatever<< [2, 3, 4] | ||
| p6eval | niecza v17-2-gb8fcf85: OUTPUT«Unhandled exception: Ran off end of non-dwimmy left at /home/p6eval/niecza/lib/CORE.setting line 1364 (die @ 3)  at /home/p6eval/niecza/lib/CORE.setting line 3019 (ANON @ 18)  at /home/p6eval/niecza/lib/CORE.setting line 3026 (_hyper_posi @ 6)  at /… | ||
|
19:02
GlitchMr joined
|
|||
| Celelibi | what is <go blue> ? | 19:02 | |
| masak | Celelibi: ('go', 'blue') | ||
|
19:02
wolf2k_bahhumbug joined
|
|||
| GlitchMr | perl6: print sqrt -1 | 19:02 | |
| Celelibi | like qw ? | ||
| p6eval | pugs, rakudo d9fd17, niecza v17-2-gb8fcf85: OUTPUT«NaN» | ||
| colomon | yes | ||
| masak | Celelibi: to a first approximation, yes. | ||
| GlitchMr | perl6: print sqrt(-1 + 0i) | ||
| Celelibi | ok | ||
| p6eval | rakudo d9fd17: OUTPUT«6.12303176911189e-17+1i» | ||
| ..niecza v17-2-gb8fcf85: OUTPUT«6.1230317691118863E-17+1i» | |||
| ..pugs: OUTPUT«0 + 1i» | |||
| masak | Pugs++ | ||
|
19:03
eviltwin_b joined,
geekosaur left,
eviltwin_b is now known as geekosaur
19:04
wolf2k_bahhumbug left
19:05
wolf2k_away left
|
|||
| sisar | aye, Pugs++ | 19:06 | |
|
19:09
eviltwin_b joined,
geekosaur left,
eviltwin_b is now known as geekosaur
|
|||
| Celelibi | masak: and what's the difference between <> and qw ? | 19:09 | |
| cognominal | none, I think | 19:10 | |
| Celelibi | And can I, in some way use the meta operators >> and/or << on more that two arguments? | 19:12 | |
| cognominal | r: say << a b > < c >> # except that you can do it multilevel | 19:13 | |
| p6eval | rakudo d9fd17: OUTPUT«a b > < c» | ||
|
19:13
geekosaur left
|
|||
| Celelibi | I don't understand that line. | 19:14 | |
| cognominal | r: say << a b > < c >>.perl # except that you can do it multilevel | ||
| p6eval | rakudo d9fd17: OUTPUT«("a", "b", ">", "<", "c")» | ||
|
19:15
geekosaur joined
|
|||
| masak | Celelibi: <> has val() semantics. (see S02). qw doesn't. | 19:15 | |
|
19:16
birdwindupbird joined
|
|||
| Celelibi | cognominal: this is just a list... | 19:16 | |
| I don't get it. | |||
| masak | Celelibi: cognominal wants to show off that if you have a '<' inside the <> list, you can just delimit with <<>> instead. | ||
| Celelibi | ok | 19:17 | |
| masak | and so on. | ||
| cognominal | you can't do that with qw | ||
| masak | cognominal: in Perl 5, you can't. | ||
| cognominal: this is #perl6 :P | |||
|
19:17
_dolmen_ joined
|
|||
| cognominal | I am watching the Almadovar, so I am not very attentive | 19:17 | |
| masak | n: .say for qw<<< > >> >>> | 19:18 | |
| p6eval | niecza v17-2-gb8fcf85: OUTPUT«>>>» | ||
| Celelibi | ok ok | ||
| masak .oO( I thought he was called the Hollande... ) | |||
| cognominal | …in spanish to make it more challenging | ||
| masak | n: .say for qw<[< a b c >]> | 19:19 | |
| p6eval | niecza v17-2-gb8fcf85: OUTPUT«[<abc>]» | ||
|
19:20
Mescale joined
|
|||
| Celelibi | oh oh, was the ">>." in "Str.methods(:all)>>.name" the metaoperator >> applied on "."? | 19:22 | |
| masak | conceptually, yes. | ||
| Celelibi | which means "actually no"? :) | ||
| masak | "." isn't really an operator. | ||
| or rather, if it's an oprator, it's a rather strange one. | 19:23 | ||
| Celelibi | hum... Is >>. the operator as whole? | ||
| masak | in the sense that >>+<< is the operator as a whole, yes. | ||
| Celelibi | ok so this >>. is actually part of the language while >>+<< is not. right? | 19:24 | |
| tadzik | no, it's just a combo | ||
| gfldex | r: my @a = 1,2,3; say @a>>.?foo; | 19:25 | |
| p6eval | rakudo d9fd17: OUTPUT«Nil Nil Nil» | ||
| masak | Celelibi: it's all just parsing. there's no real "actually part of the language" distinction. | ||
| Celelibi | what is .? | ||
| masak | Celelibi: it's a dottyop | ||
| Celelibi: see STD.pm6 :) | |||
| Celelibi: or did you ask 'what is C<.?>?' :) | 19:26 | ||
| Celelibi: it's "call method, but don't mind if dispatch fails". | |||
| cognominal | everything is more or less dotty in Perl 6 :) | ||
| Celelibi | I mean fucking connect my brain to that computer so that I know everything! | ||
| :p | |||
| gfldex | Celelibi: perlcabal.org/syn/S12.html#Calling_...of_methods | ||
|
19:27
geekosaur left
|
|||
| gfldex | it's like a twigil but not :-> | 19:28 | |
| Celelibi | what means "call all the methods"? | 19:29 | |
| masak | Celelibi: it means call all the methods. | ||
| Celelibi | How can there be several appliable methods? | ||
|
19:29
geekosaur joined
|
|||
| masak | Celelibi: inheritance. | 19:29 | |
| Celelibi | ok | ||
| gfldex | how does that play with MMD? | 19:30 | |
| masak | r: class A { method foo { say "A" } }; class B is A { method foo { say "B" } }; B.new.*foo | ||
| p6eval | rakudo d9fd17: OUTPUT«BA» | ||
| Celelibi | So $obj.*methods will call the methods of $obj and its parents. | ||
| masak | gfldex: very well. | ||
| Celelibi: $obj doesn't have parents. its class does. and it's not just the parents, it's all applicable methods, any level up. | |||
| Celelibi | parents | 19:31 | |
| ok | |||
| masak | that's not the point :) | ||
| Celelibi | I fogot about the multiple inheritance. | ||
| masak | "parents" only indicates the case of MI. | ||
| you meant "ancestors" or something. | |||
| Celelibi | yes. | ||
| masak | don't blame me for your being inexact :P | ||
| TimToady | parent's parents are parents too :P | ||
| Celelibi | English is not my native language. :) | ||
| masak | TimToady: yes, but not $obj's. | 19:32 | |
| Celelibi: neither is it mine. | |||
| I suspect that there's more non-native English speakers here than native ones. | |||
|
19:32
geekosaur is now known as allbery_b
|
|||
| Celelibi | possibly. :) | 19:32 | |
| TimToady | regarding whether . is an operator, not by itself; rather it's considered to introduce a postfix, so the whole method call is the postfix operator | 19:33 | |
|
19:33
eviltwin_b joined
|
|||
| masak | ah. | 19:33 | |
| learn something every day ;) | |||
| Celelibi | And can I declare several methods that could match the same arguments? | ||
| TimToady | and some of our native English speakers have studied linguistics, which means they don't know how the language works anymore either | 19:34 | |
| cognominal | a spread postfix then. | ||
| masak | Celelibi: yes, if you declare them 'multi'. | ||
|
19:34
allbery_b left
|
|||
| Celelibi | ok | 19:34 | |
| and I guess .* will call them all. | |||
|
19:34
Mescale left
|
|||
| masak | hm, with .* you don't need the 'multi'. | 19:34 | |
| as I showed above. | |||
| Celelibi | r: class A { method foo { say "A" } }; class B is A { method foo { say "B" } method foo {say "C"} }; B.new.*foo | 19:35 | |
| p6eval | rakudo d9fd17: OUTPUT«===SORRY!===Unable to parse blockoid, couldn't find final '}' at line 2» | ||
| Celelibi | r: class A { method foo { say "A" } }; class B is A { method foo { say "B" }; method foo {say "C"} }; B.new.*foo | ||
| p6eval | rakudo d9fd17: OUTPUT«===SORRY!===Package 'B' already has a method 'foo' (did you mean to declare a multi-method?)» | ||
| moritz | note that classes usually have to be explicitly designed for .* use, otherwise .* won't work as expected | ||
| Celelibi | r: class A { method foo { say "A" } }; class B is A { multi method foo { say "B" }; multi method foo {say "C"} }; B.new.*foo | ||
| p6eval | rakudo d9fd17: OUTPUT«Ambiguous call to 'foo'; these signatures all match::(B , Mu *%_):(B , Mu *%_) in method foo at src/gen/CORE.setting:293 in method dispatch:<.*> at src/gen/CORE.setting:821 in block <anon> at /tmp/Ebas_rsdm9:1» | ||
| TimToady | .* is kind of a power tool; it can cut your arm off really quick | 19:36 | |
| add in >> and it'll gladly cut off all your limbs | 19:37 | ||
|
19:37
Mescale joined
|
|||
| Celelibi | I guess from the last error that .* cannot call several methods in the same class. | 19:37 | |
| TimToady | nope | ||
| you can only do that if you add 'multi' | 19:38 | ||
| and then distinguish the type sigs enough so that's not ambiguous | |||
| Celelibi | didn't I put multi in the right place? | ||
| masak | Celelibi: your problem wasn't .* at all | ||
| TimToady | you didn't distinguish the signatures | ||
| masak | Celelibi: your problem was an ambiguous dispatch. | 19:39 | |
| Celelibi | r: class A { method foo { say "A" } }; class B is A { multi method foo { say "B" }; multi method foo (int $a = 0) {say "C"} }; B.new.*foo | ||
| p6eval | rakudo d9fd17: OUTPUT«Ambiguous call to 'foo'; these signatures all match::(B , Mu *%_):(B , int $a = { ... }, Mu *%_) in method foo at src/gen/CORE.setting:293 in method dispatch:<.*> at src/gen/CORE.setting:821 in block <anon> at /tmp/u2sOxmc5rI:1» | ||
| masak | Celelibi: generally, if you make your method signatures exactly the same, you'll get one. | ||
| TimToady | .* isn't meant to help with that | ||
| jnthn | Remember that .* is *only* about the MRO | ||
| masak | Celelibi: 'multi' really only makes sense if you also make sure to make your signatures different enough. | ||
| jnthn | The multi-dispatch is then a secondary dispatch *after* normal method dispatch. | 19:40 | |
| Celelibi | ok | ||
| jnthn | And the "call all the things" semantics is not applied recursviely into the proto's dispatch. | ||
| Celelibi | MRO ? | ||
| jnthn | Method Resolution Order. Basically, "what order do we visit classes in to find the method"? | ||
| TimToady | if you really need to call a set of indentical signatures, just shove 'em in a data structure and call 'em with >>. | ||
| jnthn | When you have multiple inheritance, there's more than one way you could walk the tree. | ||
| Celelibi | ok | 19:41 | |
| TimToady | s/indent/ident/ | ||
| Celelibi | I think I get it. | ||
| TimToady | good questions though | ||
| it's not something we've always "got" ourselves | 19:42 | ||
| moritz regularly confuses how inheritance and multi methods interact | 19:43 | ||
| and I think we've been back and forth a few times about how it should be | |||
| masak | I also think I get it now. | ||
| well, nowadays, I should say. since about mid-2011. | 19:44 | ||
| it's really quite pretty. | |||
|
19:44
not_gerd left
|
|||
| masak | and yeah, keeping the MRO and the proto/multi bits apart is kinda important ;) | 19:44 | |
| jnthn wishes it had been so obvious from the start, so he didn't have to re-implement all the things... | 19:45 | ||
| TimToady | we'll all be smart by the time this is done :) | 19:46 | |
| jnthn | ;) | ||
| TimToady | otoh, I hope we're all dead before this is done too, in the 100-year-language sense :) | 19:47 | |
| masak | I hope we're all alive by the time this is done, in the 100-year language sense... :) | 19:48 | |
| TimToady | the Plurality is Near! | ||
| I suppose it doesn't have to be me, as long as it's somebody who thinks he's me... | 19:49 | ||
| The Strong Turing Test: emulating you so well that you don't know whether you're the real you or not... | 19:51 | ||
| masak | TimToady: you reminded me of blog.plover.com//brain/immortality.html | 19:52 | |
|
19:52
jaldhar left
|
|||
| TimToady | yes, I've always liked that one. | 19:53 | |
| masak | something about all that bothers me; can't quite say what. | 19:54 | |
| TimToady | s/you don't know/neither of you knows/ | ||
| well, the whole issue rests on the extent to which your identity includes the reality in which you're embedded | 19:55 | ||
| Celelibi | <TimToady> The Strong Turing Test: emulating you so well that you don't know whether you're the real you or not... <-- please stop messing with my mind! :p | ||
| moritz | Celelibi: you'll have to get used to that if you hang around here for longer :-) | 19:56 | |
| TimToady | um...no? :P | ||
| eviltwin_b | shatterday? | ||
| TimToady | sorry, I mess regularly with my own mind, and some of it naturally wanders out into the reality in which I am embedded | 19:57 | |
| masak | *lol* | ||
| jnthn | moritz: Latest on use-malice is...import works and I need to look at export? | 19:58 | |
| masak .oO( we have a level-3 TimToady containment breach... all personel to section 4A of the reality in which TimToady is embedded... ) | |||
|
19:58
eviltwin_b is now known as geekosaur
|
|||
| moritz | jnthn: correct | 19:59 | |
| Celelibi | TimToady: I already do this myself. I don't really need more. :) | ||
| jnthn | Pulled...building. :) | ||
| masak | personnel* | ||
| TimToady | .oO(the Gray Geek Catastrophe) |
||
| masak | TimToady: :D | ||
| moritz | jnthn: it works when I build the export tag myself :-) | ||
| jnthn | moritz: OK :) | 20:00 | |
| masak | TimToady: weirdest mental image today: Guido van Rossum, riding the Googleplex, trying to fend of an ocean of your brain with a pitchfork. | ||
| jnthn | So, design question | ||
| masak | off* | 20:01 | |
| jnthn | sub foo is export(:lol, :wut) { } | ||
| What gets passed to the trait_mod there? | |||
| Clearly :export is passed. | |||
| Then do we get: a) two named args, :lol and :wut, or b) one positional arg, which is a Parcel containing two Pairs? | |||
| TimToady: ^^ :) | |||
| cognominal | sometimes, #perl6 sounds like inception, the movie. | ||
|
20:02
GlitchMr left
|
|||
| TimToady | 'is export' is 'long shorthand' for :export so the rules of :export(:lol, :wut) apply, which is to say it's the same as export => (:lol, :wut) | 20:02 | |
| Celelibi | inception is a fary tale. :) | ||
| moritz | jnthn: how about a a Capture containing two pairs? | ||
| Celelibi | (Well, I don't thing about Alice in wonderland) | ||
| moritz | carlin: as is #perl6. Oh, wait... | ||
| erm, meant Celelibi | 20:03 | ||
| Celelibi: intellectual milk and honey flow in generally friendly atmosphere | |||
| jnthn | TimToady: Oh. :) | ||
| TimToady: Not the answer I expected, but I can implement that one :) | |||
| masak | moritz: though milk flows better than honey. | 20:04 | |
| moritz | masak: yes, but having two different viscosities makes for much more interesting flow patterns | ||
| masak | ooh, yes. | 20:05 | |
| (different viscosities)++ | |||
| TimToady suspects that honey stays liquid-ish at a temperature where milk freezes... | |||
| [Coke] , in backscroll, wonders if we can have a Modula-3 TimToady containment breach instead. | |||
| TimToady | [Coke]: the breach is Oberon the other side from where you're looking... | 20:06 | |
| masak | if I ever form a post-anarchist unplugged punk duo with someone, I'm gonna name it "Two Different Viscosities". | ||
|
20:06
fhelmberger joined
|
|||
| masak | TimToady: When you look into an ABSYS, the ABSYS also looks into you. | 20:08 | |
| ooh, ABSYS was a Prolog precursor... | 20:09 | ||
| TimToady | well, so? Neutrinos are into physicists... | ||
| geekosaur | and everyone else | ||
| Celelibi | masak: this may sound quite sexual in some ways. :) | 20:10 | |
| TimToady | and everything else | ||
| masak | Celelibi: I have such an innocent mind that the thought didn't even occur to me. | 20:12 | |
|
20:13
Kresike left
|
|||
| Celelibi | I wish I would think a bit less sometime. | 20:13 | |
| masak | that's an unusual wish. | 20:14 | |
| [Coke] | TimToady: *groan* | ||
| masak | though not entirely unreasonable. | ||
| Celelibi: tried meditation? | |||
| tadzik | that's one of the reasons for drinking alcohol, I guess | ||
| one once said "I drink so I tolerate people I spend my time with" | 20:15 | ||
| [Coke] | masak: I often complain that my brain is full. That's almost the same complaint. | ||
| Celelibi | masak: actually it's not the "quantity" it's what I think to. | ||
| masak | Celelibi: nevertheless. | 20:16 | |
| Celelibi | tadzik: that's right, I'm a bit more open minded when I'm drunk. :) | 20:17 | |
| masak notes for the first time that Celelibi's nick could be seen as a portmanteau of "celibate" and "libido" | |||
| tadzik | :> | ||
| masak | tadzik: I try to seek out friends that I'm able to stand when sober. | ||
| Celelibi | Tell me more about your innocence masak. :) | 20:18 | |
| tadzik | masak: same :) | ||
| masak | Celelibi: I was totally not serious. my father is the King of innuendo, srsly. | ||
| TimToady | as opposed to friends who will help you stand when you're not sober? | ||
| tadzik | :) | ||
| masak | TimToady: incidentally, those overlap quite well :) | 20:19 | |
| TimToady | overlap!?!? | ||
| masak | *lol* | ||
| Celelibi | I learned a new word today: "innuendo". | ||
| masak .oO( must be something they put in the #perl6 welcome punch tonight... ) | 20:20 | ||
| sisar | tadzik: read my earlier comment? re panda build fails | ||
| tadzik | sisar: yeah, seen that, but that's the same thing here | 20:21 | |
|
20:21
Mescale left,
tyatpi left
|
|||
| sisar | does make parallize on its own or do i need to tell it to ? | 20:22 | |
| Celelibi | is "hyperoperator" synonymous for "meta operator" ? | ||
| make -j 8 | |||
| tadzik | sisar: that's not the thing, sadly :/ | 20:23 | |
| sisar | oh, ok, fine :) | ||
|
20:23
ponbiki left
|
|||
| cognominal | <tadzik> one once said "I drink so I tolerate people I spend my time with". Paul Valéry said "un homme seul est toujours en mauvaise companie" : a man alone is aways in bad company, but I suppose you did not mean it that way :) | 20:23 | |
| Celelibi | If I understand correctly in perl6 there are less {} and more <>. :) | 20:24 | |
| tadzik | cognominal: nope :) | ||
| masak | Celelibi: no, the hyperops are just a type of metaop. | ||
| Celelibi: reduction ops are another type. | |||
| Celelibi | hyperoperators are only >> and << ? | 20:25 | |
| masak | aye. | ||
| Celelibi | ok | ||
| masak | and the things that go between them :) | ||
| Celelibi | ok | ||
| so >>+<< as a whole is an hyperoperator. | |||
| TimToady | yes, we use the term both ways | 20:26 | |
| Celelibi | is >>+>> also one? | ||
| TimToady | yes, but that one's dwimmy on the right | ||
| Celelibi | dwimmy? | 20:27 | |
| cognominal | I said that Perl 6 is dotty, I forgot to said it was loopy too | ||
| TimToady | perl6: say (1,2,3) »+« (1,2) | ||
| p6eval | niecza v17-2-gb8fcf85: OUTPUT«Unhandled exception: Ran off end of non-dwimmy right at /home/p6eval/niecza/lib/CORE.setting line 1364 (die @ 3)  at /home/p6eval/niecza/lib/CORE.setting line 3020 (ANON @ 19)  at /home/p6eval/niecza/lib/CORE.setting line 3026 (_hyper_posi @ 6)  at … | ||
| ..pugs: OUTPUT«243» | |||
| ..rakudo d9fd17: OUTPUT«Sorry, lists on both sides of non-dwimmy hyperop are not of same length: left: 3 elements, right: 2 elements in sub hyper at src/gen/CORE.setting:10792 in block <anon> at src/gen/CORE.setting:10773 in block <anon> at /tmp/BygWuXgsSN:1» | |||
| TimToady | perl6: say (1,2,3) »+« (1,2,3) | ||
| p6eval | pugs: OUTPUT«246» | ||
| ..rakudo d9fd17, niecza v17-2-gb8fcf85: OUTPUT«2 4 6» | |||
| TimToady | perl6: say (1,2,3) »+» (1,2) | ||
| p6eval | pugs: OUTPUT«***  Unexpected "\187+\187" expecting operator, ":" or "," at /tmp/3kODkyzBcV line 1, column 13» | ||
| ..rakudo d9fd17, niecza v17-2-gb8fcf85: OUTPUT«2 4 4» | |||
| TimToady | perl6: say (1..10) »+» (1,2) | 20:28 | |
| p6eval | rakudo d9fd17, niecza v17-2-gb8fcf85: OUTPUT«2 4 4 6 6 8 8 10 10 12» | ||
| ..pugs: OUTPUT«***  Unexpected "\187+\187" expecting operator, ":" or "," at /tmp/S1kzO_7N9V line 1, column 13» | |||
| TimToady | other metaops have different policies, for instance | ||
| masak | Celelibi: DWIM means "Do What I Mean", i.e. employ some context-sensitive logic to figure out some thing that is not explicitly stated. in the case of >>+>>, make the right-hand list as long or short as makes sense. | ||
| TimToady | perl6: say 1..10 Z+ 1..3 | 20:29 | |
| p6eval | pugs: OUTPUT«12345678910» | ||
| ..rakudo d9fd17, niecza v17-2-gb8fcf85: OUTPUT«2 4 6» | |||
| masak | Celelibi: Perl 5 uses a lot of DWIM that (from the perspective of Perl 6) is considered deprecated. | ||
| TimToady | a 'zip' metaop just trims to the shorter of the two lists | ||
| Celelibi | ok | ||
| TimToady | since you can't have a zipper with only one side | ||
| masak was gonna say | |||
| Celelibi | And yes, that was a question I had last time. What does mean "make the list as long as needed"? | 20:30 | |
| By repeating its elements? | |||
| TimToady | depends on what is making the list as long as needed | ||
| masak .oO( innuendo ) | |||
| TimToady | with hypers, it repeats the short side | ||
|
20:31
phenny left,
phenny joined
|
|||
| TimToady | with a degenerate (!?!) case that a single element just repeats | 20:31 | |
| Celelibi | ok, and the list extended/shortened is the one on the "small side" of the >> | 20:33 | |
| TimToady | if it's the xx operator, it just repeats the list on the left | ||
| Celelibi | what's the equivalent of x operator in perl5? | 20:34 | |
| masak | x | ||
| unless you want the list-context variant, then it's xx | |||
| TimToady | r: say (1..10) »+» (1..20) | ||
| p6eval | rakudo d9fd17: OUTPUT«2 4 6 8 10 12 14 16 18 20» | ||
| TimToady | yes, the dwimmy side can shorten as well as repeat | ||
| Celelibi | r: say (1 .. 10)x2 | ||
| p6eval | rakudo d9fd17: OUTPUT«===SORRY!===Confusedat /tmp/ToHwjimFfT:1» | ||
| Celelibi | what's wrong? | 20:35 | |
| TimToady | std: say (1 .. 10)x2 | ||
| p6eval | std fab64fc: OUTPUT«===SORRY!===Whitespace is required between alphanumeric tokens at /tmp/biESrIXzTw line 1:------> say (1 .. 10)x⏏2Check failedFAILED 00:00 42m» | ||
| TimToady | n: say (1 .. 10)x2 | ||
| p6eval | niecza v17-2-gb8fcf85: OUTPUT«===SORRY!===Whitespace is required between alphanumeric tokens at /tmp/5UXVcpE1LS line 1:------> say (1 .. 10)x⏏2Unhandled exception: Check failed at /home/p6eval/niecza/boot/lib/CORE.setting line 1364 (die @ 3) … | ||
| tadzik | masak: autopun? "Hypochondria is the only illnes I don't have" | ||
| TimToady | what's wrong is that rakudo isn't quite using the standard parser yet | ||
| jnthn | moritz: Think I've got it workin' :) | 20:37 | |
| Celelibi | but it don't seem to work either with niecza | 20:38 | |
| jnthn | moritz: But it turned out a bunch of other traits were relying on the arg being passed int he wrong way, so been clearing up that. | ||
| masak | tadzik: yeah :P | ||
| TimToady | n: say (1..10) x 2 | ||
| p6eval | niecza v17-2-gb8fcf85: OUTPUT«1 2 3 4 5 6 7 8 9 101 2 3 4 5 6 7 8 9 10» | ||
| masak | tadzik: though I would turn it around for maximum punch. | ||
| TimToady | n: say (1..10) xx 2 | ||
| p6eval | niecza v17-2-gb8fcf85: OUTPUT«1 2 3 4 5 6 7 8 9 10 1 2 3 4 5 6 7 8 9 10» | ||
| tadzik | masak: I saw it turned around in one film I think | 20:39 | |
| TimToady | Celelibi: it works if you read the error message :P | ||
| tadzik | masak: "Hypochondria?" "Yeah, it's the illnes that (...describes...)" "Oh my god. I have that too!" | ||
| masak | tadzik: :P | ||
|
20:40
sivoais left
|
|||
| Celelibi | TimToady: they are hard to read with these escape codes. | 20:40 | |
| masak | tadzik: yeah, I'm probably silly to want to turn it around. the usual way with autopuns is mention + use, in that order. | ||
| Celelibi: check the IRC logs. | |||
|
20:40
fhelmberger left
|
|||
| TimToady | Celelibi: which IRC client are you using? irssi just shows things in colors, since those are terminal color codes | 20:41 | |
| Celelibi | masak: they're stored in the logs. :) | ||
| TimToady: xchat. | |||
|
20:41
sivoais joined
|
|||
| Celelibi | these are color codes for a terminal, not for irc. :) | 20:41 | |
| TimToady | I'm on a terminal | ||
| tadzik | weechat doesn't show them | ||
|
20:41
birdwindupbird left
|
|||
| geekosaur | mmm, yes, I need a script to do something about the broken ansi x3.64 codes in those | 20:42 | |
| (also xchat) | |||
| Celelibi | the best fix would be that p6eval translate them to irc color codes. :) | ||
| geekosaur | indeed | 20:45 | |
|
20:45
fhelmberger joined
|
|||
| sisar | is rosettacode.org/wiki/Sorting_algori...ort#Perl_6 using a feature which is NYI in rakudo? coz it hangs Rakudo, but works fine in Niecza. | 20:45 | |
| Celelibi | and so... <<+>> is just like a regular + ? | 20:46 | |
| diakopter | sisar: how long did you wait while it was hanging? | ||
| sisar | 2-3 mins... | ||
| should i wait moar ? | 20:47 | ||
| diakopter | how long did niecza take | ||
| sisar | diakopter: 3 seconds. | ||
| diakopter | oh; hm | ||
| hard to tell (to me) | 20:48 | ||
| I guess it's worth trying again and waiting longer until someone replies with more knowledge | |||
| sisar | diakopter: when people ask the time, should i report the real, user, or sys time ? | 20:49 | |
| diakopter | wall clock, I guess | ||
| eh | 20:50 | ||
| TimToady | Celelibi: it's only like regular + if you feed it two numbers. Otherwise + will try to coerce to numbers, so lists return the number of elements with bare +, whereas <<+>> will try to apply across lists | ||
| sisar | i mean "time perl6 <script-nae>" reports three times, right? | ||
| dalek | kudo/use-arglist: 6fa9034 | jnthn++ | src/ (3 files): Refactor handling of traits taking named arguments. The argument is now passed along with the name. Updated various of the built-in traits along with this. |
||
| kudo/use-arglist: f9a94d8 | jnthn++ | src/core/traits.pm: Handle export tags. |
|||
| jnthn | moritz: There you go. :) A test in advent2009-day12.t fails, but looking at it, I think it's wrong. | 20:51 | |
| Celelibi | TimToady: yep I saw. It expand the shortest list. | ||
| r: say ((1, 2, 3) X (4, 5, 6)).perl | |||
| p6eval | rakudo d9fd17: OUTPUT«((ListIter.new(),), (ListIter.new(),), (ListIter.new(),), (ListIter.new(),), (ListIter.new(),), (ListIter.new(),), (ListIter.new(),), (ListIter.new(),), (ListIter.new(),)).list» | ||
| jnthn | moritz: Also a trait one, but should be an easy fix when merging. | 20:52 | |
| Celelibi | what does that mean? :) | ||
| jnthn | r: say ((1, 2, 3) X (4, 5, 6)) | ||
| masak | Celelibi: means you're in over your head :P | ||
| p6eval | rakudo d9fd17: OUTPUT«1 4 1 5 1 6 2 4 2 5 2 6 3 4 3 5 3 6» | ||
| jnthn | Celelibi: Just Rakudo being lazy :) | ||
| (That is, not evaluating stuff until it has to.) | |||
| Celelibi | ok, these are lazy lists. | ||
| jnthn | Looks like... | 20:53 | |
| Celelibi | How do I force the evaluation of an expression? | ||
| jnthn | .eager should do it. | ||
| r: say ((1, 2, 3) X (4, 5, 6)).eager.perl | |||
| p6eval | rakudo d9fd17: OUTPUT«((ListIter.new(),), (ListIter.new(),), (ListIter.new(),), (ListIter.new(),), (ListIter.new(),), (ListIter.new(),), (ListIter.new(),), (ListIter.new(),), (ListIter.new(),)).list» | ||
| jnthn | Hm... | ||
| [Coke] | jnthn: at this rate, all the advent tests will eventually break. | ||
| jnthn | r: say ((1, 2, 3) X (4, 5, 6)).flat.perl | ||
| p6eval | rakudo d9fd17: OUTPUT«(1, 4, 1, 5, 1, 6, 2, 4, 2, 5, 2, 6, 3, 4, 3, 5, 3, 6).list» | ||
| diakopter | sisar: 60x slower for some operations wouldn't be surprising a while ago; I don't know about recently | ||
| [Coke] | as long as we do so intentionally and not accidentally, that's the best I can hopef or. | ||
| jnthn | That flattens it out at least. | ||
| Celelibi | why flat? | 20:54 | |
| I do not want it flat. :) | |||
| jnthn | Celelibi: Well, .tree it or something then :) | ||
| TimToady | r: say ((1, 2, 3) X (4, 5, 6)).tree.perl | ||
| p6eval | rakudo d9fd17: OUTPUT«([1, 4], [1, 5], [1, 6], [2, 4], [2, 5], [2, 6], [3, 4], [3, 5], [3, 6]).list» | ||
| jnthn | Celelibi: Things don't commit to flat or structured until you put them in a context that makes them do so. | ||
| [Coke]: I don't see how this one could ever have worked on an implementation that does import tags correctly. | 20:55 | ||
| Celelibi | ok | ||
| jnthn | [Coke]: It relies on something being in :DEFAULT, when the exporting module is putting it elsewhere. | ||
| Celelibi | then flat method appies a list context in the data. | ||
| and tree? | 20:56 | ||
|
20:56
envi_ left
|
|||
| TimToady | doesn't :) | 20:56 | |
| jnthn | LoL context, or whatever we call it... :) | ||
| [Coke] | jnthn: it was 2009. We didn't know any better! | ||
| TimToady | lol only goes one level down | ||
| jnthn | Troo. | ||
| [Coke] | no, *tree* | 20:57 | |
|
20:57
_Vi joined
|
|||
| TimToady | and X should be returning Parcels | 20:57 | |
| so it can come out (1,4),(1,5),(1,6) etc... | |||
| jnthn | [Coke]: :P | ||
| TimToady: Well, that's just how it comes out once everything gets reified... | |||
| TimToady: I guess you're saying it's being a bit too lazy? | 20:58 | ||
| TimToady | seems so | ||
| Celelibi | Hum... My version of rakudo do not evaluate the lazy lists with .tree | ||
| TimToady | x knows perfectly well how many elements it's returning each time, and that they're scalars | ||
| X* | |||
| it's only the outer list of parcels needs to be lazy | 20:59 | ||
| jnthn | TimToady: OK. Maybe masak++ would be so good as to rakudobug this; pmichaud++ may be trolled into fixing it or commenting "yes, just needs X" :) | ||
| masak | r: say 1, 2, 3 X* 4, 5, 6 | ||
| p6eval | rakudo d9fd17: OUTPUT«4 5 6 8 10 12 12 15 18» | ||
| masak | jnthn: can I do it tomorrow. my mana is too low right now... :) | 21:00 | |
| or someone else could, too... | |||
| sisar | "mana" ? | ||
| jnthn | masak: Sure :) | ||
| TimToady | polynesian god power | ||
| jnthn | sisar: masak is fed by food falling from the sky, but not much fell today, depleting his energy... | ||
| [Coke] | r: (1..6 X* 1..6).uniq.sort.say | 21:01 | |
| p6eval | rakudo d9fd17: OUTPUT«1 2 3 4 5 6 8 9 10 12 15 16 18 20 24 25 30 36» | ||
| TimToady wonders if masak has played Populace... | |||
|
21:01
kaare_ left
|
|||
| [Coke] | masak: coding taks mana and not health? hurm. | 21:02 | |
| TimToady | er, Populous... | ||
| [Coke] | *takes | ||
| Celelibi | How could I create a lazy list myself? | 21:03 | |
| tadzik | using gather take | ||
| Celelibi | To create an infinite list for instance. | ||
| tadzik | r: my @a = gather for 1..* { take $_ * 2 }; say @a[^30] | 21:04 | |
| eek, eager assignment :/ | 21:05 | ||
| p6eval | rakudo d9fd17: OUTPUT«(timeout)» | ||
| masak | [Coke]: compiler hacking takes mana: strangelyconsistent.org/blog/perl-6-is-my-mmorpg | ||
| tadzik | r: my @a := gather for 1..* { take $_ * 2 }; say @a[^30] | ||
| p6eval | rakudo d9fd17: OUTPUT«2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 40 42 44 46 48 50 52 54 56 58 60» | ||
| Celelibi | := ? | ||
| TimToady | there are a number of easier ways to make infinite lists | 21:06 | |
| sisar zz.. | 21:07 | ||
| masak | Celelibi: binding, as opposed to assignment. | ||
| TimToady | it depends on how fancy you need the list to be | ||
| note that tadzik's example starts with the infinite list 1..* | |||
| Celelibi .oO(Y U SO SLOW TO LEARN BRAIN?!) | |||
|
21:08
skids left
|
|||
| TimToady | (well, techinically, it's an infinite range that gets turning into an infinite list...) | 21:08 | |
| and the even numbers are more easily written just as 2,4,6...* | |||
| Celelibi | How heavy is the CPU-cost of making a lazy list? | 21:09 | |
| TimToady | so generally you don't need to write your own gather most of the time | ||
| Celelibi: a lot lighter than generating the whole list | |||
| </rimshot> | |||
| masak | unless the whole list is empty... | ||
| TimToady | serious answer: heavier currently than we hope it will be in the future | ||
| Celelibi | I hope so, indeed. :) | 21:10 | |
| masak .oO( native lazy lists o.O ) | |||
| Celelibi | But does it make sens to make every list lazy? | ||
| I think not. | |||
| TimToady | the compiler is free to optimize when it can determine there's an eager context | 21:11 | |
| Celelibi | I think lists of tenth of elements are not worth lazying. | ||
| TimToady | and the lazy implementation is allowed to batch things up for efficiency | 21:12 | |
| Celelibi | what does mean eager actually? | ||
| and the gather keyword? And take? | |||
| I think "take" means "stop execution here, take this value" | 21:13 | ||
| TimToady | gather/take is essentially our coroutine interface, but it's orthogonal to function calls | ||
| Celelibi | (and we'll continue execution for the next value) | ||
| TimToady | yes, take, is a 'yield' | ||
| Celelibi | ok. | ||
| TimToady | but easier to spell | ||
| Celelibi | indeed. | 21:14 | |
| diakopter | beavers can be eager. gather is a gospel singer/songwriter. | ||
| Celelibi | and gather means "lazy expression follow here"? | ||
| or lazy list only? | |||
| TimToady | it means to set up a coroutine and/or thread | 21:15 | |
| with a thread, the insides could work ahead until the pipeline stalls | |||
| Celelibi | ok. | ||
| TimToady | again, up to the compiler | ||
| Celelibi | but the programmer then have to handle the synchronization on its own (if any). | 21:16 | |
| I mean, mutex and stuff. | |||
| TimToady | no, the compiler would have to handle the handshaking if it implements it that way | ||
| Celelibi | can it? | 21:17 | |
| TimToady | if a gather's code depends on side-effects from outside, then it's likely erroneous | ||
| but if it depends on other lazy lists, that's okay, since those can block automatically till there are values available | 21:18 | ||
| Celelibi | I thought about that, and cannot figure out a use case where this would make sens. But that does not mean it doesn't make sens at all. | ||
| TimToady | we're trying to make Perl 6 very multicore/manycore friendly | ||
| so a lot of the constructs are promising what you don't care about, to give room for the compiler to do whatever is best | 21:19 | ||
| whether that's mapping to manycores, or pipeline processors, or GPUs... | |||
| our current compilers don't try to do any of that, so they're necessarily a little slow to emulate parallelism | 21:21 | ||
| Celelibi | I think these places where parallelism can occur will have to be well documented since it will be the source of numerous insidious bugs. | 21:22 | |
| If you did some parallel coding you should know how there bugs are hard to track. :) | 21:23 | ||
| and randomly appears. | 21:24 | ||
| and disappear... | |||
| TimToady | certainly, but generally the more you stick to the FP way of doing things, the safer you'll be, since it's usually side effects that get you into trouble | 21:25 | |
| Celelibi | FP? Functionnal programming? | 21:26 | |
| TimToady | OO also helps, insofar as side-effects are encapsulated into objects | ||
| yes | |||
| Celelibi | k | ||
| ow ow ow. Does "gather" create a closure? | |||
| TimToady | we recognize that we are multiplying the possibilities for people to write erroneous code, but so far we haven't run into many problems | 21:27 | |
| the block form does | |||
| Celelibi | nice. | ||
| TimToady | but usually we just use 'gather' as a prefix for a loop that has its own closure | ||
| Celelibi | ok, then this lower the risk of unpredictable behavior. | 21:29 | |
| TimToady | unpredictable behavior is not always completely evil, either, as long as the rocketship stays on course | 21:31 | |
| Celelibi | indeed. | ||
| TimToady | the trick is to know when you care, and when you don't | ||
| so all of the parallel constructs in Perl 6 tend to make you swear that you don't care :) | 21:32 | ||
| apart from the guarantess of the particular constructs | |||
| hypers still preserve order, even though they don't care what order the computation proceeds | 21:33 | ||
| likewise gather will return elements in the order that take sends them | |||
| Celelibi | One thing I was thinking about was a lazy/infinite list that rely upon I/O to construct continuous flow of elements. And when the input change, the list elements will eventyally change. You don't know when, you only know this will happen. | ||
| -y+u | |||
| But well, the lists may not be well suitied for a flow. | 21:35 | ||
| (suited?) | |||
| TimToady | r: for '/dev/random'.IO.comb -> { say .ord } | 21:36 | |
| p6eval | rakudo d9fd17: OUTPUT«Method 'comb' not found for invocant of class 'IO' in block <anon> at /tmp/rzUIx934xc:1» | ||
| Celelibi | I'm sure there are use case for things like this. | ||
|
21:37
jferrero joined
|
|||
| TimToady | r: for '/dev/random'.IO.lines».comb -> { say .ord } | 21:37 | |
| p6eval | rakudo d9fd17: OUTPUT«Malformed UTF-8 string in method get at src/gen/CORE.setting:6611 in code <anon> at src/gen/CORE.setting:6632 in sub coro at src/gen/CORE.setting:4926 in method reify at src/gen/CORE.setting:4907 in method reify at src/gen/CORE.setting:4678 in method r… | ||
| TimToady | r: for open('/dev/random', :raw).lines».comb -> { say .ord } | ||
| p6eval | rakudo d9fd17: OUTPUT«open is disallowed in safe mode in sub restricted at src/SAFE.setting:2 in sub open at src/SAFE.setting:5 in block <anon> at /tmp/QEoAmVvyp6:1» | ||
| TimToady | aww | ||
| we don't seem to have any iterating method defined on binary files yet; read just reads a single buf, not a sequence of them | 21:40 | ||
| and you can't use slurp on an infinite file | 21:41 | ||
| Celelibi | thought /dev/random is not infinite /dev/urandom is; | ||
| TimToady | anyway, that should certainly be possible, mapping a binary file to a lazy list | 21:42 | |
| currently we can do it with .lines on a text file | |||
| Celelibi | I think "take" forces the evaluation of its expression. | 21:43 | |
| TimToady | well, on some level that does not include eager-izing the list | 21:44 | |
| n: my @a := gather loop { take 2,4,6...* }; say @a[^10] | 21:45 | ||
| p6eval | niecza v17-2-gb8fcf85: OUTPUT«(timeout)» | ||
| TimToady | innersting | ||
| r: my @a := gather loop { take 2,4,6...* }; say @a[^10] | |||
| p6eval | rakudo d9fd17: OUTPUT«2 4 6 8 10 12 14 16 18 20» | ||
| TimToady | looks like a nieczabug | ||
| Celelibi | how does perl infer the list I want? | ||
| r: say 1, 2, 3 ... 10 | 21:46 | ||
| p6eval | rakudo d9fd17: OUTPUT«1 2 3 4 5 6 7 8 9 10» | ||
| Celelibi | r: say 1, 3, 5 ... 10 | ||
| r: say 1, 3, 5 ... 11 | |||
| p6eval | rakudo d9fd17: OUTPUT«(timeout)» | ||
| rakudo d9fd17: OUTPUT«1 3 5 7 9 11» | |||
| TimToady | see S03:1806 | ||
| Celelibi | r: say 1, 3, 5 ... 10 | ||
|
21:46
Guest40378 left
|
|||
| Celelibi | interesting. | 21:47 | |
| p6eval | rakudo d9fd17: OUTPUT«(timeout)» | ||
| TimToady | that's an infinite loop | ||
|
21:48
_dolmen_ left
|
|||
| TimToady | bbl & | 21:51 | |
|
21:52
tyatpi joined
21:53
xenu joined
|
|||
| Celelibi | oh, are closures and thread nice to combine in perl6? | 21:53 | |
|
21:53
xenu is now known as Guest21759
|
|||
| Celelibi | I think I made perl5 crash with things like returning a function (with a closure from inside a map coderef or something like that) as a result of a thread. | 21:54 | |
|
22:06
jferrero left
22:12
jferrero joined
22:26
whiteknight joined
22:33
James joined
22:34
James is now known as Guest69870
22:36
fhelmberger left
|
|||
| jnthn | 'night, #perl6 | 22:39 | |
|
22:41
tokuhirom joined,
fgomez left
22:42
PacoAir left
22:49
bluescreen10 left
22:51
fgomez joined
22:54
Guest69870 left
23:04
Timbus left
|
|||
| gfldex | p6: class A { class Str {}; method new() { return Str.new }; }; say A.new.WHAT; | 23:06 | |
| p6eval | pugs: OUTPUT«Str» | ||
| ..rakudo d9fd17, niecza v17-2-gb8fcf85: OUTPUT«Str()» | |||
|
23:06
Timbus joined
|
|||
| gfldex | is there any way to get hold of the outer class name? | 23:06 | |
|
23:07
skids joined
|
|||
| gfldex | p6: package A { class Str {}; method foo() { return Str.new }; }; say foo.WHAT; | 23:08 | |
| p6eval | pugs: OUTPUT«*** No such subroutine: "&foo" at /tmp/IziyrsP17y line 1, column 67-75» | ||
| ..niecza v17-2-gb8fcf85: OUTPUT«===SORRY!===A package cannot have methods added at /tmp/3bLD3APrKG line 1:------> package A { class Str {}; method foo⏏() { return Str.new }; }; say foo.WHAT;Undeclared routine: 'foo' used at line 1Potential diff… | |||
| ..rakudo d9fd17: OUTPUT«Useless declaration of a has-scoped method in package===SORRY!===CHECK FAILED:Undefined routine '&foo' called (line 1)» | |||
| gfldex | p6: package A { class Str {}; method foo() { return Str.new }; }; say (A::foo).WHAT; | ||
| p6eval | pugs: OUTPUT«*** No compatible multi variant found: "&A::foo" at /tmp/g4zjF335HE line 1, column 68-74» | ||
| ..niecza v17-2-gb8fcf85: OUTPUT«===SORRY!===A package cannot have methods added at /tmp/eQ4ydRPDaL line 1:------> package A { class Str {}; method foo⏏() { return Str.new }; }; say (A::foo).WPotential difficulties: 'method' declaration outside o… | |||
| ..rakudo d9fd17: OUTPUT«Useless declaration of a has-scoped method in packageCould not find symbol 'A::&foo' in block <anon> at /tmp/x_cIUUBbOz:1» | |||
| gfldex | p6: package A { class Str {}; sub foo() { return Str.new }; }; say (A::foo).WHAT; | ||
| p6eval | rakudo d9fd17: OUTPUT«Could not find symbol 'A::&foo' in block <anon> at /tmp/P_yi5zLoUR:1» | ||
| ..niecza v17-2-gb8fcf85: OUTPUT«Potential difficulties: &foo is declared but not used at /tmp/iQmOxjP6q0 line 1:------> package A { class Str {}; sub foo⏏() { return Str.new }; }; say (A::foo).WUnhandled exception: Unable to resolve method postcircumfix:<( )> in cl… | |||
| ..pugs: OUTPUT«Str» | |||
| gfldex | p6: package A { class Str {}; our sub foo() { return Str.new }; }; say (A::foo).WHAT; | 23:09 | |
| p6eval | pugs: OUTPUT«Str» | ||
| ..niecza v17-2-gb8fcf85: OUTPUT«Str()» | |||
| ..rakudo d9fd17: OUTPUT«===SORRY!===This type cannot box a native string» | |||
| gfldex | :) | ||
| n: say Str.^methods; | 23:10 | ||
| p6eval | niecza v17-2-gb8fcf85: OUTPUT«Unhandled exception: Unable to resolve method methods in class ClassHOW at /tmp/pHIchPEjyY line 1 (mainline @ 3)  at /home/p6eval/niecza/lib/CORE.setting line 3840 (ANON @ 3)  at /home/p6eval/niecza/lib/CORE.setting line 3841 (module-CORE @ 65)  at … | ||
| gfldex | n: say Str.new.^methods; | ||
| p6eval | niecza v17-2-gb8fcf85: OUTPUT«Unhandled exception: Unable to resolve method methods in class ClassHOW at /tmp/jlOmCxTZcI line 1 (mainline @ 4)  at /home/p6eval/niecza/lib/CORE.setting line 3840 (ANON @ 3)  at /home/p6eval/niecza/lib/CORE.setting line 3841 (module-CORE @ 65)  at … | ||
| sorear | don't bother | ||
| gfldex | p6: package A { class Str {}; our sub foo() { return Str.new }; }; say (A::foo).chomp; | 23:11 | |
| p6eval | pugs: OUTPUT«<obj:Str>» | ||
| ..niecza v17-2-gb8fcf85: OUTPUT«Unhandled exception: Unable to resolve method chomp in class Str at /tmp/BusWEUMYFX line 1 (mainline @ 4)  at /home/p6eval/niecza/lib/CORE.setting line 3840 (ANON @ 3)  at /home/p6eval/niecza/lib/CORE.setting line 3841 (module-CORE @ 65)  at /home/p… | |||
| ..rakudo d9fd17: OUTPUT«===SORRY!===This type cannot box a native string» | |||
| gfldex | niecza is doing the right thing as it seams | ||
| gfldex finds his rakudobug pencil | 23:12 | ||
|
23:13
REPLeffect left,
REPLeffect joined
|
|||
| moritz | r: my $f = open(:bin, '/dev/urandom'); say $f.read(20) | 23:14 | |
| p6eval | rakudo d9fd17: OUTPUT«open is disallowed in safe mode in sub restricted at src/SAFE.setting:2 in sub open at src/SAFE.setting:5 in block <anon> at /tmp/CslPnRpCyt:1» | ||
| moritz | r: my $f = '/dev/urandom'.IO; say $f.read(20) | ||
| p6eval | rakudo d9fd17: OUTPUT«Method 'read_bytes' not found for invocant of class 'Any' in method read at src/gen/CORE.setting:6638 in block <anon> at /tmp/KwbBSL_MsL:1» | ||
|
23:15
_ilbot left,
_ilbot joined
|
|||
| gfldex | std: package A { class Str {} our sub foo() } | 23:16 | |
| p6eval | std fab64fc: OUTPUT«===SORRY!===Strange text after block (missing comma, semicolon, comment marker?) at /tmp/oUZxkkwmjC line 1:------> package A { class Str {}⏏ our sub foo() } expecting any of: infix or meta-infix infixed function statement… | ||
| gfldex | std: package A { class Str {} sub foo() } | ||
| p6eval | std fab64fc: OUTPUT«===SORRY!===Strange text after block (missing comma, semicolon, comment marker?) at /tmp/QgsC1Eytse line 1:------> package A { class Str {}⏏ sub foo() } expecting any of: infix or meta-infix infixed function statement | ||
| ..mod… | |||
| gfldex | std: package A { class Str {} sub foo(){} } | ||
| p6eval | std fab64fc: OUTPUT«===SORRY!===Strange text after block (missing comma, semicolon, comment marker?) at /tmp/QFqrtjHfGG line 1:------> package A { class Str {}⏏ sub foo(){} } expecting any of: infix or meta-infix infixed function statement | ||
| ..m… | |||
| gfldex | std: package A { class Str {}; sub foo(){} } | ||
| p6eval | std fab64fc: OUTPUT«ok 00:00 41m» | ||
| dalek | blets: 62f4516 | (Herbert Breunung)++ | docs/tablet-2-basic-syntax.txt: start working on tablet 2 |
23:17 | |
|
23:18
fgomez left
23:20
fgomez joined
23:25
Timbus left,
Timbus joined
|
|||
| raiph | re: "The Strong Turing Test: emulating you so well that you don't know whether you're the real you or not..."; www.newbanner.com/SecHumSCM/WhereAmI.html | 23:33 | |
|
23:45
jferrero left
23:49
Chillance left
23:53
NamelessTee left
|
|||