pugscode.org/ | nopaste: sial.org/pbot/perl6 | pugs: [~] <m oo se> (or rakudo:, kp6:, elf: etc.) (or perl6: for all) | irclog: irc.pugscode.org/ Set by Tene on 29 July 2008. |
|||
00:00
ruoso joined
00:03
Chillance left
00:08
cotto_work joined
00:09
Khisanth left
|
|||
ruoso | TimToady, I really didn't get what you mean... | 00:09 | |
00:09
Khisanth joined
|
|||
TimToady | map {...}, $x never treats $x like an iterator | 00:11 | |
map {...}, |$x is needed if $x contains an iterable object | 00:12 | ||
map {...}, @x is non-destructive because @x constructs a new iterator to put in the list | 00:13 | ||
map {...}, =$fh is destructive because $fh just returns itself as its iterator | |||
ruoso | TimToady, so I get back to my question... what is the API to traverse the array without forcing eager evaluation... | ||
because even if we think on map as an operator... it still needs to be represented in terms of method calls to the input object | 00:14 | ||
TimToady | an @a in list context returns a special iterator that the list can use, and how that works is between the array and the iterator | ||
ruoso | right... | 00:15 | |
but what's the api to access that? | |||
and also... what happens in "map { ... }, $x" when $x is an array object? | 00:16 | ||
TimToady | internally when you need the next value from the list, it either returns the next real value or the prefix:<=> of its first "spec" iterator | ||
but "spec" iterators are hidden | |||
nothing happens to $x; its value is poked straight into the list of real values, not specs | 00:17 | ||
ruoso | I mean... is $x treated as a list? or is it passed as the only value into a single iteration of map? | ||
TimToady | $x is always just itself in list context | ||
scalar variables are never treated as composite objects unless you do something to indicate you want that | 00:18 | ||
merely putting $x into a list is not enough to indicate that | |||
ruoso | ok... so that's determined by syntax... | ||
TimToady | @$x or |$x | ||
lambdabot | Maybe you meant: . ? @ bf ft id pl rc thx v wn | ||
TimToady | it's one of the reasons we still have sigils | ||
ruoso | right... | ||
ruoso trying to put his ideas together... | 00:19 | ||
TimToady | many objects can be used either in the singular or the plural, and we make that explicit | ||
00:20
xinming_ is now known as xinming
|
|||
TimToady | likewise, (1,2,3) is a plural view of the list, while [1,2,3] is a singular view | 00:21 | |
ruoso | Ok... that solves the part that is "visible"... | ||
TimToady | which is why plural (1,2,3) turns into singular [1,2,3] in item context | 00:22 | |
00:22
bacek joined
|
|||
TimToady | (arguably, confusing mutability) | 00:23 | |
ruoso | TimToady, when map needs the next value, what does it mean in terms of method calls on the array to "return the next real value"? | 00:26 | |
TimToady | map never sees the array. the list has already asked the array for an iterator, and runs that iterator when map wants another value | ||
ruoso | right... that's partly what I was thinking already | 00:27 | |
but what "runs that iterator" mean in terms of method calls? .prefix:<=> ? | |||
TimToady | probably | 00:28 | |
don't see why not | |||
the point is that various languages either force you to track your own iterators, or have them implicitly floating around after "first call", and in Perl both of those approaches are considered a bit bogus | 00:29 | ||
the list data structure is the natural place for iterators to live once they are created | |||
00:31
alanhaggai joined
|
|||
TimToady | so the list manages the iterator objects for you most of the time, and you don't have to manage them explicitly most of the time | 00:31 | |
ruoso | hmm... | ||
ruoso trying to figure out what the means in the low level... | 00:32 | ||
ok... in the low-level there's no "implicit"... | |||
so, even if the syntax helps you so that "you don't have to manage them explicitly", the iterators are managed independently... | 00:33 | ||
TimToady | if you call =$fh in scalar context, you're doing explicit iteration. =$fh in list context merely installs $fh in the "todo" list of iterators | 00:34 | |
note that you can't actually decide which till binding time | |||
ruoso | because an "iterator in list context create a new lazy list" | 00:35 | |
TimToady | well, essentially an inner capture interpolates into an outer capture at that point, which is why list context flattens | 00:36 | |
00:36
kanru joined
|
|||
TimToady | slice context would keep the inner capture discreet | 00:36 | |
discrete, rather | 00:37 | ||
00:37
bacek left
00:38
bacek joined
|
|||
ruoso trying to put the pieces together... | 00:41 | ||
TimToady, I think I found one confusing point... Is there an "Iterator" type? or is that just a way to access the list? | 00:51 | ||
the reason why that is relevant is because an iterator is not supposed to provide positional access... an iterator can only be consumed... | 00:58 | ||
that way, in "map {...}, map {...}, (1,2,3)", the left map receives just an iterator, and not a list... | 01:00 | ||
that fits well with the fact that an iterator in list context creates a lazy list... | 01:02 | ||
and also makes it clear that the return of the 'map' in the right has no obligation of providing positional access to the values... | 01:05 | ||
and we also can have a generic Lazy List implementation that receives an iterator object... | 01:06 | ||
01:06
Lichtkind_ joined
|
|||
ruoso | map would then receive an iterator and return another iterator... | 01:10 | |
TimToady, do you think that's sane? | 01:15 | ||
01:21
Lichtkind left
|
|||
ruoso sleep & | 01:25 | ||
TimToady | seems sane to me, as long as when you say (map {...}, 1,2,3)[$index] you're transforming the iterator to a list and treating the list as subscriptable or turning it into a subscriptable array maybe | 01:41 | |
decommuting & | 01:45 | ||
02:04
hercynium joined
02:06
cathya left
02:14
alc joined
02:23
meppel-san joined,
Myoma left
02:33
hercynium left
02:36
eternaleye_ joined,
eternaleye left
02:38
meppl left
02:45
yahooooo joined
02:52
meppel-san is now known as meppl
02:55
alester left
03:02
elmex_ joined
03:10
xuser joined
03:16
Auzon joined
03:17
elmex left,
elmex_ is now known as elmex
03:23
Bzek left,
Bzek joined
03:31
ting left
03:32
AzureStone joined
03:34
ting joined,
ting left
03:35
ting joined
03:37
BinGOs_ joined
03:39
Alias_ joined
03:43
yahooooo left
03:44
eternaleye_ left
03:45
eternaleye_ joined,
sri_work_ left
03:47
yahooooo joined
03:56
BinGOs left
04:07
yahooooo left
04:24
Alias_ left,
alanhaggai left
|
|||
meppl | good night | 05:04 | |
05:05
meppl left
05:23
Psyche^ joined
05:28
justatheory left
05:37
Patterner left,
Psyche^ is now known as Patterner
06:03
zostay_ joined
06:08
zostay left
06:10
xuser_ joined
06:13
Maghnus left
06:22
xuser left,
luqui joined
06:27
ashizawa joined
|
|||
eternaleye_ | Hi, I've been golfing around, and I figured a good way to test myself would be generating <a b c d> X <a b c d> in a way that was easily extensible to longer resulting strings than 2 characters. As is, I could chain on additional 'X <a b c d>'s, but that felt inelegant. So, I tried using the [op] reduce operator, xx, and slice context to get what I wanted. I arrived at 'say $_ for [X] @@ <a b c d> xx 2 ;' but it didn't | 06:38 | |
work, even with various attempts at using parentheses for scope. Any ideas? | |||
moritz_ | [X] doesn't amek sense for operators that return a list | 06:45 | |
or does it? | 06:46 | ||
eternaleye_: maybe what you wrote is right, but pugs doesn't support slice context | 06:47 | ||
eternaleye_: so it won't work with pugs | |||
and other iimplementations don't do hyper ops | |||
eternaleye_ | X is a list infix operator, so shouldn't [X] @@( @foo @bar @baz ) do the same as [~] <mo os e> ? | ||
Ah, pugs not having slice context would do it | 06:48 | ||
Thanks! | |||
moritz_ | anyway, this looks evil ;) | 06:50 | |
06:53
alc left
|
|||
eternaleye_ | Just think: for ( 1 .. 6 ) -> $foo { say $_ for [X] @@ <a b c d> xx $foo; } could be a reasonably effective password bruteforcing oneliner ;P | 06:57 | |
moritz_ | omg ;) | 06:58 | |
eternaleye_ | s/<a b c d>/[ a .. z, A .. Z, 0 .. 9 ]/ | ||
Occasionally, Perl6's expressive power makes me think, "APL? We don't need no stinking APL!" | 06:59 | ||
It is a decidedly nice language | 07:00 | ||
07:01
jferrero joined
|
|||
eternaleye_ | Even cooler is that I seem to recall there being a whole Perl5 module to do that ;D | 07:04 | |
moritz_ | Algorithms::NestedLoops or something like that | ||
07:10
luqui left
07:14
BinGOs_ is now known as BinGOs
07:33
zamolxes left
07:34
viklund joined,
iblechbot joined
07:48
Auzon left
08:12
masak joined
08:31
apeiron_ left
08:33
Maghnus joined
08:34
alanhaggai joined
08:49
mj41_ left
09:00
cosimo joined
09:04
elmex_ joined
09:17
elmex left,
elmex_ is now known as elmex
09:18
pim joined
09:19
pim left
09:21
pim joined
|
|||
pim | hi, everybody. | 09:21 | |
masak | hi, pim | ||
pim | why this doesn't work in perl 6 : my $n=7; if $n>3) {say "$n est bigger than 3"} ? | 09:22 | |
masak | pim: too many ')'? :) | ||
pim | Yes but, that's just a mistake i have not in my real script. | 09:23 | |
i do it again. | |||
masak | perl6: my $n = 7; if $n > 3 { say "\$n is bigger than 3" } | ||
p6eval | elf 22120: OUTPUT[\$n is bigger than 3ā¤] | ||
..pugs, rakudo 30722: OUTPUT[$n is bigger than 3ā¤] | |||
pim | my $n=7; if $n>3 {say "$n est bigger than 3"} | ||
masak | pim: it works, see above. | ||
have you tried it with whitespace around the binary operators? | 09:24 | ||
pim | YES. | ||
masak | pim: well, as you see, it works here. | ||
what implementation of Perl 6 are you running? | |||
Pugs, Rakudo...? | 09:25 | ||
and what revision? | |||
pim | Here are my two lines of my script: | 09:26 | |
[11:37] [pim(+i)] [2:#perl6(+Jnt 30,3)] [Act: 1] | 09:27 | ||
[#perl6] | |||
sorry | |||
I give you the values ... | |||
masak | yes? | 09:31 | |
viklund | pim: it works for me if I put it in a script, but if I run it through -e 'code' it fails | ||
pim | OK, i come to see the error comes from other part of my script: it's as melting pot script and when i put ONLY this test in it doesn't crash, so i must analyse more... | ||
probably precedent instruction... | 09:32 | ||
masak | viklund: I get the same thing. care to send a rakudobug about this? | ||
viklund: hold on. no, it works. | 09:33 | ||
false alarm. | |||
pim | I use two version of perl 6 perfectly isolated themselves. | ||
masak | this works here: perl6 -e 'my $n = 7; if $n > 3 { say "$n is bigger than 3" }' | ||
pim | the error is produced only for '>' test : not for '<' | 09:34 | |
masak | pim: could you nopaste the exact commands you're running? | ||
pim | I have warnings complaints when starting my script about precedent instuctions. | ||
moritz_ | rakudo doesn't do any warnings yet | 09:35 | |
pim | Really sorry bur I don't know how to nopaste : can you explain to me? | ||
moritz_ | sial.org/pbot/perl6 | ||
lambdabot | Title: sial.org Pastebot - pasteling | ||
pim | thank's ... | 09:36 | |
pasteling | "pim" at 82.230.45.94 pasted "sial.org Pastebot - pasteling, pim test.pl" (21 lines, 378B) at sial.org/pbot/32072 | 09:38 | |
pim | Stored at sial.org/pbot/32072 | 09:39 | |
lambdabot | Title: Paste #32072 from "pim" at 82.230.45.94 | ||
pim | Right. | ||
I use pugs AND perl6 compiled with parrot and both do the same error. | 09:40 | ||
I give you my versions now ... | 09:41 | ||
masak | pim: seems to me the loop {} construct right before is interfering | ||
you're onto something here | |||
09:41
Myoma joined
|
|||
pim | Sorry : don't understant well :O| did i mistake in my script? | 09:43 | |
masak | pim: no, pugs and rakudo are at fault | 09:44 | |
you've found a bug | |||
(I think) | |||
pim | right : may i put this in my CV. | 09:45 | |
This is Rakudo Perl 6, revision 30402 built on parrot 0.7.0-devel | 09:46 | ||
for i486-linux-gnu-thread-multi. | |||
This is parrot version. | 09:47 | ||
compiled by myself. | |||
masak | oki | ||
and you have a sufficiently recent Rakudo, since I'm getting the same error | |||
09:49
bacek left,
cosimo left
|
|||
masak | pim: smallest file that produces the error is this: 'loop () {\n}\nmy $n' | 09:50 | |
without the parens, the error goes away. | |||
pim: could you write about this to rakudobug? | |||
pim | i'll do. | 09:52 | |
masak | pim++ | ||
gotta go, see you later | 09:53 | ||
09:53
masak left
09:56
alanhaggai left,
cosimo joined
10:07
alanhaggai joined
10:12
alanhaggai left
10:14
alanhaggai joined
|
|||
pim | I posted the bug, i did write [BUG] at the begining of the subject. | 10:39 | |
and described the most i could the situation when it occurs, and included,versions and complains for both versions, pugs and perl6 parrot versions. | 10:41 | ||
i leave for now. thank's to all of you. | 10:45 | ||
10:46
pim left
|
|||
moritz_ | pim, I changed to the subject of the RT ticket to be a bit more descriptive... too late | 10:47 | |
10:53
ruoso left
11:00
pmurias joined
11:07
meppl joined
11:11
iblechbot left
|
|||
pmurias | TimToady: when is the context determined? | 11:20 | |
11:53
masak joined
11:54
meppl left
|
|||
masak | is there a binary comparison operator in Perl 6 according to which two different arrays (say, two separate [1,2] arrays) are the equivalent? | 12:06 | |
12:07
pmurias left
|
|||
masak | basically, what I'm looking for is some kind of &is_deeply | 12:07 | |
12:12
zamolxes joined
12:16
alanhaggai left,
alanhaggai joined
|
|||
viklund | masak: I was actually thinking of implementing that tonight | 12:20 | |
masak | viklund: heh. :) | ||
I was just wondering about operator support for it | |||
ISTR there was someway one could inflict deep semantics on one of the operators using an adverb | 12:21 | ||
but maybe I dreamt that.... | |||
viklund | I can't find anything in S03, should be in there, but I only skimmed it | 12:23 | |
masak | same here. | 12:24 | |
I had my hopes on eqv for a while, but it seems that's not what "snapshot semantics" mean | |||
viklund | no | 12:25 | |
moritz_ | masak: it's just structural equivalence, afaict | 12:26 | |
really afk & | |||
masak greps S03 for 'structural equivalence' | 12:27 | ||
moritz_: what is? and how? Show Me The Code! :) | |||
12:30
iblechbot joined
12:57
ashizawa left
13:12
iblechbot left
13:22
PZt left
13:25
PZt joined
|
|||
moritz_ | masak: there's no code ;) | 13:49 | |
masak | moritz_: but what did you mean? | 13:50 | |
moritz_ | masak: I thought you were trying to implement it, but didn't understand the specs | 13:52 | |
13:52
jferrero left
|
|||
masak | moritz_: no, I'm thinking how best to express structural equivalence in Perl 6 | 13:53 | |
14:08
rindolf joined
|
|||
masak | maybe `@a <<==>> @b`? | 14:16 | |
14:17
rindolf left
|
|||
moritz_ | only if they are both made of numbers, and neither the numbers nor the arrays contain mixins | 14:17 | |
14:18
TJCRI joined
|
|||
masak | hm, yes | 14:18 | |
moritz_ | the eqv operator is in Perl 6 because there's no trivial way to express it in Perl 6 ;) | 14:19 | |
masak | seems there is no trivial way to express structural equivalence either... | 14:22 | |
[particle] | eeqqvv ;) | ||
moritz_ | lol | ||
masak | haha | ||
.EQV. | |||
moritz_ | I think $a eqv $b is kinda like $a.perl eq $b.perl, if .perl sorts hashes etc. | 14:23 | |
[particle] | ooh, look! it's 1977 again! | ||
14:25
meppl joined
14:27
rindolf joined
14:42
zostay_ is now known as zostay
14:51
rindolf left
14:56
sri_work joined
14:57
Exodist joined
15:04
rindolf joined
15:12
viklund left
15:13
alester joined
|
|||
moritz_ | we'll loose our logging bots (and me) in a few mintues | 15:20 | |
15:21
hercynium joined,
rindolf left
15:22
moritz joined
15:28
moritz_ left,
ilbot2 left
15:29
Jedai joined
15:30
Exodist left
15:31
masak left
15:36
Exodist joined
15:49
zamolxes left
16:10
rdice joined
16:11
masak joined
16:12
apeiron joined
16:17
iblechbot joined
16:21
Lichtkind_ left
|
|||
pugs_svn | r22121 | moritz++ | [t] move lazy.t to spec/ | 16:22 | |
16:30
rindolf joined
|
|||
pugs_svn | r22122 | moritz++ | [t] moved chained.t to spec/, don't rely on the exact output of .perl | 16:30 | |
r22122 | moritz++ | and changed dies_ok to eval_dies_ok | |||
masak | moritz++ # test suite pumpking | 16:31 | |
we're hackathoning now, btw | |||
moritz | masak: what was that channel again? | ||
masak | #november-wiki :) | ||
moritz | do you want that logged? | 16:32 | |
masak | gladly. | ||
just haven't gotten around to asking. | |||
16:32
ilbot2 joined
|
|||
masak | moritz: thank you. :) | 16:33 | |
16:34
moritz_ joined,
moritz left,
alanhaggai left
|
|||
masak | viklund++ has the first workaround to #58392! | 16:35 | |
16:36
rindolf left
|
|||
TimToady | eqv is structural equiv as long as the types match; there's no such operator if the types to not match, since different types serialize differently | 16:40 | |
16:40
justatheory joined
|
|||
TimToady | s/to no/do not/ | 16:40 | |
masak | TimToady: ok, so bringing that down to the example [1,[2,3]] | 16:41 | |
TimToady | @tel pmurias context of what? if you're asking what I think you're asking, binding time | ||
lambdabot | Consider it noted. | ||
masak | what does [1,[2,3]] eqv [1,[2,3]] do? | ||
moritz_ | return true | ||
(as far as I understood) | 16:42 | ||
masak | ok, that's all I need | ||
TimToady | yes, that should be true | ||
eqv is "would the serializer produce the same sequence of bytes for both of these?" | |||
masak | ok, good | 16:43 | |
16:43
malouin left
|
|||
TimToady | naĆÆve implementation can just serialize and compare strings | 16:43 | |
fast implementation can short circuit on mismatches without serializing all of both first | |||
pugs_svn | r22123 | moritz++ | [t/spec] a bit of fiddeling in S03-operators/ | 16:44 | |
TimToady | we also assume hash keys are sorted | ||
masak | I don't get line 44 of t/spec/S29-any/eqv.t in the light of this discussion | ||
TimToady | are you asking about "snapshot"? | 16:45 | |
masak | my @a = (1,2,3); my @b = (1,2,3); ok !(\@a eqv \@b), "eqv on array references (3)"; | ||
it's checking that they are _not_ eqv | |||
whereas I think they should be | |||
TimToady | I think there's some p5-think in that test | 16:46 | |
moritz_ | ie the test is wrong? | ||
masak | aye | ||
TimToady | yes | ||
wait | |||
it's correct, I think | 16:47 | ||
problem is that it's got actual variables | |||
does \@a serialize to something that includes, say, the variable name? | |||
or its location? | 16:48 | ||
masak | ah | ||
16:48
Chillance joined
|
|||
moritz_ | pugs: my @a = (1, 2, 3); say (\@a).perl | 16:48 | |
p6eval | pugs: OUTPUT[\(1, 2, 3)ā¤] | ||
TimToady | problem is that the value includes a notion of uniqueness | ||
if you serialize (\@a,\@b) and then deserialize, it has to turn into 2 distinct arrays | 16:49 | ||
and how does it know to do that? | |||
moritz_ | it does it automatically with pugs' output | ||
16:49
c9s joined
|
|||
moritz_ | pugs: my @a = (1, 2, 3); say (\@a, \@a).perl | 16:49 | |
p6eval | pugs: OUTPUT[(\(1, 2, 3), \(1, 2, 3))ā¤] | ||
moritz_ | whereas this is wrong | ||
because .[0] !=== .[1] | 16:50 | ||
TimToady | it's the same problem as serializing a closure, really--you end up with the symbol tables coming along for the ride | 16:51 | |
moritz_ | you can serialize it to something like do { my @a = (1, 2, 3); (\@a, \@a) }; | 16:52 | |
(which is roughly what Data::Dumper) | 16:53 | ||
TimToady | but you still need to keep @a and @b distinct, so the test is correct | ||
moritz_ | :( yes | 16:54 | |
pugs_svn | r22124 | moritz++ | [t] moved var/var.t to spec/ | 16:57 | |
TimToady | bbl & | ||
masak | so, the conclusion is: (1) the test was correct, (2) I can still do what I want, comparing two different arrays, yes? | 16:59 | |
(I got lost in the discussion, so I need to confirm) | |||
pugs_svn | r22125 | moritz++ | [t] move var/is_readonly.t to spec | ||
moritz_ | you can, but presumably not their captures (I think) | ||
masak | oh, that's fine. | 17:00 | |
pugs_svn | r22126 | moritz++ | [t] moved sub_parameter_traits to spec/ | 17:03 | |
17:05
alanhaggai joined
17:06
ruoso joined
|
|||
pugs_svn | r22127 | moritz++ | [t/spec] fudged S06-traits/misc.t for rakudo | 17:07 | |
17:10
pmurias joined
17:11
cognominal left
|
|||
rakudo_svn | r30729 | moritz++ | [rakudo] add traits test to spectest_regression | 17:12 | |
17:12
cognominal joined
|
|||
pmurias | TimToady: context of function/method calls | 17:12 | |
lambdabot | pmurias: You have 4 new messages. '/msg lambdabot @messages' to read them. | ||
17:13
stef_ left
|
|||
pmurias | TimToady: so a capture evaluates it's arguments only after the binding? and how do we know which variant of a multi to choose before evaluating the multi argument, or are they a special case and receive no/limited context | 17:15 | |
ruoso | pmurias, I plan to do that pre-checking with .ACCEPTS and only .BIND after the signature matches the capture... | 17:18 | |
pmurias | ruoso: hi | 17:19 | |
seems resonable | |||
pugs_svn | r22128 | moritz++ | [t] moved a few tests to spec/ | ||
17:20
pmurias left
|
|||
pugs_svn | r22129 | moritz++ | [t] move tests for is (tighter|equiv|looser) to spec/ | 17:22 | |
17:24
rdice left
|
|||
pugs_svn | r22130 | moritz++ | [t] really delete duplicate test | 17:24 | |
17:31
zamolxes joined
|
|||
pugs_svn | r22131 | moritz++ | [t/spec] re-add accidentially deleted smartmatch.t | 17:34 | |
moritz_ | moritz-- # removing test files accidentially | 17:36 | |
17:37
cosimo left
|
|||
rakudo_svn | r30731 | moritz++ | [rakudo] one more test for spectest_regression | 17:39 | |
ruoso | pmurias, btw... after all the debate... "map" is again an operator instead of a method of Array... | 18:06 | |
moritz_ | but only in the low level bootstrapping, right? | 18:08 | |
I think the "special" thing should be for, not map | |||
and map can be implemented in terms of for | |||
[particle] | map doesn't guarantee order | 18:09 | |
for does, iirc | |||
so it seems for is better suited to be defined at a lower level | |||
moritz_ | then it's easier to implement map in terms of for than the other way round ;) | ||
[particle] | yep | 18:10 | |
18:10
Bzek left
|
|||
ruoso | [particle], moritz_, "map" and "for" are actually synonyms... | 18:20 | |
both are lazy... both return the values... | 18:21 | ||
moritz_ | and yet "for" appears in the grammar (because it has two terms in a row), and map doesn't | ||
masak | ruoso: not in the sense that 'for' and 'foreach' are synonyms in Perl 5 | ||
moritz_: right. that was my point as well, I think :) | 18:22 | ||
moritz_ | or to put it this way: map is part of the Prelude, for is part of the language itself | ||
ruoso | masak, no... they're even more synonyms than that... | ||
masak | even more? :) | ||
ruoso: what moritz_ said. | |||
[particle] | hrmm, okay then | ||
now that you mention it, i remember that discussion | 18:23 | ||
ruoso | for is only part of the language because it has no "," after the first parameter ... | 18:24 | |
and I think map has it so it can be part of the prelude ;) | |||
18:30
mncharity joined
|
|||
TimToady | map and for differ only syntactically, not semantically | 18:33 | |
mncharity | Hi all. Been a while. Any notable highlights from the last 3 weeks or so? | 18:34 | |
moritz_ | mncharity: STD.pm now has symbol tables | ||
TimToady | sorta | ||
only global | 18:35 | ||
moritz_ | mncharity: there's now a wiki engine written in Perl 6 | ||
TimToady | but it detects most bad sub calls | ||
mncharity | neat | ||
TimToady | dunno if you were out when identifiers changed to allow embedded apostrophes and hyphens | 18:36 | |
but only if the next char is a letter | |||
mncharity | ! that's a new one for me :) | ||
moritz_ | TimToady: STD.pm complains about (1|(2|3)) with "Right-associative any, | operator" - why is that forbidden? | ||
TimToady | I did an experiment, and there were only two conflicts in the entire test suite | ||
and it makes Perl orthography more like English | 18:37 | ||
mncharity | trailing ? and ! apropos ruby and scheme? | ||
TimToady | no | ||
but it would be easy to add your own identifier rule | |||
mncharity | indeed | ||
moritz_: re wiki engine, for what p6 dialect/implementation(s)? rakudo? | 18:38 | ||
TimToady | moritz_: dunno offhand, that error doesn't look familiar | ||
masak | mncharity: yes, rakudo. currently. | ||
mncharity | nifty | 18:39 | |
masak | we haven't tried Pugs yet | ||
moritz_ | TimToady: in t/spec/S03-junctions/associative.t if you feel like investigating | ||
TimToady | mncharity: I don't know how much of the test suite was passing STD when you left, but it's 100% now, give or take quantum fluctuations | ||
mncharity | awesome. | 18:40 | |
anyone dumping and using the parses? | |||
TimToady | nach nicht | ||
mncharity | :) | ||
moritz_ | mncharity: me occasionally, for finding out WTF some constructs are supposed to mean | 18:41 | |
mncharity | lol | ||
[particle] | are the parses approaching "correct"? | ||
TimToady | adding symbol checking found much less damage than I expected | ||
[particle] | or will that only be born out of implementation? | ||
TimToady | though it found some | ||
so we're getting there, I think | 18:42 | ||
moritz_ | for example one test used |<< <a b c> (which I think is wrong anyway, but at least it parses) | ||
TimToady | sounds like (1|(2|3)) isn't right though | ||
yeah, |<a b c> should have the same effect | 18:43 | ||
moritz_ | well, |<< would apply | to each item | ||
but items don't need to be "cheated" into captures anyway, right? | |||
TimToady | |('a','b','c') is equiv to |'a', |'b', |'c' I think | ||
since items are degenerate lists | 18:44 | ||
moritz_ | ok | ||
TimToady | yes, more to the point, |'a' is equivalent to 'a' | ||
mncharity | how goes the test suite? | 18:45 | |
moritz_ | we fixed errors that STD.pm caught | ||
18:45
abra joined
|
|||
moritz_ | and I'm moving stuff as much as I reasonably can | 18:45 | |
TimToady | bare (1|(2|3)) seems to parse fine, so maybe it's something else from earlier | 18:46 | |
moritz_ | currently I'm blocking on understanding oo | ||
mncharity | did the regex tests get updated? | ||
moritz_ | to review + move the oo/ tests | ||
mncharity: don't think so | |||
mncharity | :/ | ||
18:46
rindolf joined
|
|||
moritz_ | rakudo IO was too b0rked for Auzon to work with | 18:46 | |
so the big chunk of regex tests don't run in rakudo | 18:47 | ||
he did write some tests for parsing the regexes though | |||
TimToady | moritz_: t/spec/S03-junctions/associative.t is missing a comma | ||
mncharity | ok. ah well. | ||
oo tests++ | 18:48 | ||
moritz_ stupid | |||
mncharity | I'd also like to understand oo. Perhaps a seminar or reading group? :) | ||
moritz_ | it would very much help to meet in real life for that | 18:49 | |
mncharity | campfire... | ||
TimToady | moritz_: it really ought to produce a "Two terms in a row error" somehow for that kind of error | 18:50 | |
though to be fair to STD, the green/red coding did point right to the problem | |||
moritz_ | oh, I thought that the red part was the error message | 18:51 | |
moritz_ even dumper | |||
TimToady | green/red are probably not the best colors for RG colorblindfolk though | 18:52 | |
pugs_svn | r22132 | moritz++ | [t/spec] added missing comma, TimToady++ | ||
mncharity | perhaps collaboratively writing an intro to p6 oo? on a wiki somewhere? perl.net.au? | ||
moritz_ | mncharity: in case you haven't seen it, I wrote perlgeek.de/blog-en/perl-5-to-6/ | 18:53 | |
lambdabot | Title: blog | Perlgeek.de Blog :: Category Perl-5-to-6 | ||
mncharity | looking.. | ||
moritz_ | mncharity: but it touches only the surface of OO | ||
18:54
kanru left
|
|||
masak | perl6: say 5 ~~ Scalar | 18:55 | |
p6eval | rakudo 30731: OUTPUT[Method 'ACCEPTS' not found for invocant of class 'Failure'ā¤current instr.: 'infix:~~' pc 13364 (src/gen_builtins.pir:8479)ā¤] | ||
..elf 22132: OUTPUT[Can't call method "Str" on an undefined value at ./elf_f line 649.ā¤ at ./elf_f line 3861ā¤] | |||
..pugs: OUTPUT[1ā¤] | |||
18:57
pmurias joined
|
|||
pmurias | mncharity: hi | 18:57 | |
mncharity | neat. yeah, it's WHAT etal, desugaring and control flow, underlying oo primitives, initialization, alternate reps, runtime mutation, and... etc, which are on my own puzzle list. | 18:58 | |
hi pmurias! how goes? | |||
how goes the C runtime? | 19:00 | ||
19:00
rdice joined
|
|||
mncharity | so, wrapping up... (appointment) any other highlights? | 19:02 | |
pmurias | mncharity: you mean smop? | ||
mncharity | yes | ||
pmurias | it progresses steadily | ||
TimToady | mncharity: on the performance front, STD now parses itself in <30 seconds if the lexer is pregenerated | ||
mncharity | oh wow. nifty. | 19:03 | |
TimToady | well, I'd like to squeeze another 10x out of it, but it's usable now | ||
Juerd | TimToady: That was multiple minutes before? | 19:04 | |
TimToady | also need to shrink the lexer cache, which takes an unconscionable amount of disk at the moment :) | ||
mncharity | 30 s down from... 4 min? | ||
TimToady | I think was about 2 minutes before | ||
it's still 1.5 min if you have to rebuild the cache | |||
pmurias | the cache is input independent? | 19:05 | |
TimToady | but that's only when the language changes, which is often :/ | ||
well, it's idempotent, if not independent | |||
it only generates "digraphs" for sequences it has seen | |||
so any given parse may generate more of them | 19:06 | ||
but the whole digraph scheme is just a workaround | |||
to prevent the lexer from feed TRE patterns that are too long | |||
*feeding | |||
TRE tends to go quadratic in stack space on pattern size | 19:07 | ||
I say "digraphs", but it's more like "polygraphs" since it's variable length | 19:08 | ||
it uses more characters if it thinks a hyperoperator is coming | |||
metaoperator rather | |||
since those tend to generate large token lists | |||
at some point we'll write our own DFA matcher and throw out TRE plus all its workarounds, which should simplify _AUTOLEX* | 19:10 | ||
pmurias | what's stoping you from switching from regex insanity to autmatons | ||
mncharity | big picture... has there been any, how to say it... craving for elf? volunteers stopping by? folks wishing elf did X? Eg, used STD and generated fast CL? Or... not so much? | 19:11 | |
TimToady | just tuits | ||
[particle] | timtoady: do you have any language preference for the dfa matcher, or just performance requirements? | ||
mncharity | or is elf development largely unmissed? | ||
TimToady | I would like one in Perl 6, of course, that compiles down to something as fast as C :) | 19:12 | |
moritz_ | mncharity: I'd love to have any implementation that relies on STD.pm. I don't care what it's called, as long as it's hackable | ||
[particle] | well, i asked for it.... | ||
pmurias | mncharity: elf generating m0ld code would be very nice | 19:13 | |
moritz_ | mncharity: elf doesn't even have a homepage that I can link to if I write about it, so it's hard to create demand from everybody but core p6 hackers (who ususally have a preferred implementation already) | ||
mncharity | a point | 19:14 | |
19:15
abra left
|
|||
mncharity | ok, thanks all. any last thoughts? (gotta run) | 19:15 | |
TimToady | and we all have our own preferred "hackspace" that we tend to stick to comfortzonewise if we feel like someone else owns another hackspace | 19:16 | |
moritz_ | have the appropriate amount of fun ;) | ||
mncharity | :) | ||
19:16
mj41 joined
|
|||
TimToady | not all of use are mad connect-everything-together folks like audreyt | 19:16 | |
*us | |||
mncharity | re hackspace, hmm, food for thought | 19:17 | |
tnx again & | 19:18 | ||
19:18
mncharity left
|
|||
pmichaud | I may be a few minutes late for phone today | 19:22 | |
[particle] | righty-ho | ||
pmurias | TimToady: i prefer to code on other peoples code/"hackspace" | 19:24 | |
19:25
zamolxes left
|
|||
pmurias | TimToady: it would have to be a TDFA matcher to replace TGE? | 19:29 | |
TimToady | it doesn't really need full tagging. it needs two things that a standard dfa doesn't provide | 19:30 | |
1) the ability to know which alternative matched | 19:31 | ||
2) the ability to back off to shorter matches | |||
on the other hand, it doesn't need "scanning", since tokens are always anchored | |||
and it's probably okay for a(b|c)d to be tree-ized into a(bd|cd) | 19:33 | ||
esp if it makes it easier to determine (1) | |||
or to implement (2), for that matter, since you have to know which alternative to back into | 19:34 | ||
if full tagging implies quadratic stack space theoritically, then I would say I *don't* want full tagging | 19:37 | ||
*theoretically | |||
19:37
masak left
|
|||
TimToady | (I don't know offhand if that's true though) | 19:38 | |
basically I see a lazily generated trie that knows about all the literal strings it has parsed so far, and which branches are implied by any particular traversal of the trie | 19:39 | ||
and knows when the trie runs out how to generate more from the current regex state vector | 19:40 | ||
so the second time you hit any particular literal string, you never even see the regexes | 19:41 | ||
pmurias will need a fresher brain, and some time with pen & paper to process the above | 19:42 | ||
TimToady | pmichaud is also going to be working on this, though perhaps in PIR | 19:43 | |
so you might compare notes | |||
19:43
pmurias left
|
|||
TimToady | lunch && phone & | 19:44 | |
ruoso | the biggest problem with that seems to be the space required to keep a clone state for each sub-token... | ||
ruoso wonders if there is an efficient way of composing an incremental state object instead of cloning the states... | 19:45 | ||
20:00
simcop2387 left
20:01
simcop2387 joined
20:11
meppl left
20:20
yahooooo joined
20:34
Caelum_ joined
20:39
IRSeekBot left
20:41
rindolf left
20:49
Caelum left
21:06
zamolxes joined
21:08
alester left
21:10
toddr joined,
toddr left
21:32
ruoso left
|
|||
pugs_svn | r22133 | moritz++ | [t/spec] started fudging exists.t, also fixed a typo caught by chromatic++ | 21:33 | |
21:33
toddr joined,
toddr left
|
|||
rakudo_svn | r30739 | chromatic++ | [Rakudo] Added .exists method for Hash. | 21:34 | |
pugs_svn | r22134 | moritz++ | [t/spec] fudged exists.t for rakudo, and simplified/corrected tests a bit | 21:40 | |
rakudo_svn | r30740 | moritz++ | [rakudo] added S29-hash/exists.t to spectest_regression, chromatic++ | 21:44 | |
21:47
TJCRI left
21:53
meppl joined
21:55
rdice left
21:56
BinGOs left,
BinGOs joined
22:01
BinGOs left
22:07
iblechbot left
22:10
idemal joined
22:22
Patterner left,
gbacon left
22:27
gbacon joined
22:51
Jedai left,
Psyche^ joined
22:52
Psyche^ is now known as Patterner
22:59
Exodist left
23:03
jferrero joined
23:12
Chillance left
|
|||
meppl | good night | 23:30 | |
23:31
meppl left
23:53
felipe left
23:59
Caelum_ is now known as Caelum
|