IRC channel logs

2018-09-05.log

back to list of logs

***Server sets mode: +nt
***daviid is now known as Guest30187
***Guest30187 is now known as daviid
***bnw01 is now known as bnw
<lloda>ot the renamed-as-xxx` is damn irritating, is there a way to avoid it?
<wingo>lloda: what do you mean?
<lloda>oh like I login as lloda and after a few hours it seems to connect & reconnect and then I'm lloda` and then it will happen again and I'll be lloda``
<lloda>and /nick doesn't even work because I am 'banned in channel'
<lloda>so I have to /leave to get my nick back...
<wingo>ah weird :/
<wingo>i was thinking you were referring to deprecation warnings or something :)
<lloda>ah, no worries
<lloda>I've noticed the 'redefinition' warning the most now on master
<lloda>I guess this happens to others?
<lloda>you start with a script
<lloda>everything is (define x)
<lloda>(define y)
<lloda>etc
<lloda>now you need to make a function out of it
<lloda>put everything in lets
<lloda>and now it's suddenly a lot harder to debug
<lloda>I think I read an essay about it once
<lloda>scripts-to-programs or slt
<wingo>lloda it's just a warning fwiw
<wingo>a recent one added by civodul :)
<wingo>if you think it's not the right thing, that feedback is welcome
<wingo>it hasn't hit me yet so i have no opinions
<lloda>it can be disabled, so it's ok afaic
<lloda>it flags a kind of 'program' that I think is fairly common
<lloda>at least I do it a lot :p
<civodul>lloda: you get the warning when you redefine something at the REPL/Geiser you mean?
<civodul>it would make sense to disable it by default at the REPL
<lloda>not at the repl, or I haven't noticed. It happens on scripts, which I makes sense really
<lloda>I compile them on my builds to check that I haven
<lloda>I haven't broken something with a rename etc
<lloda>I agree that this shouldn't be a warning at the REPL
<lloda>and it doesn't seem to be, at any rate (?)
<wingo>for me the warning isn't so useful, but i could see it being useful in e.g. guix
<wingo>where you have long files of things that look repetitive (but aren't), and users typically just focus on a small part of the file to modify
<lloda>is it possible to disable specific warnings from inside a file?
<lloda>sort of like a pragma
<civodul>no, but it would be nice
***heroux_ is now known as heroux
<wingo> http://infocenter.arm.com/help/topic/com.arm.doc.genc007826/Barrier_Litmus_Tests_and_Cookbook_A08.pdf is a very nice document on when barriers are needed on ARM
<wingo>though old it's apparently still valid
<dustyweb>btw davexunit
<dustyweb>maybe some ideas to snipe for starling here https://www.youtube.com/watch?v=_x0Ob2HY8C4
<wingo>oh good, i have golfed down the no-jit times in lightning to meet the 2.2 times, at least on fib
<civodul>yay! really cool
<civodul>what was the trick?
<wingo>in 3.0 conditional branches are more like a cpu, it's "compare" then "conditional branch"
<wingo>but the conditional branch always follows the compare
<wingo>before the result of the compare was stored in a vm-local variable
<wingo>after, the two opcodes are fused together, so the result is never stored anywhere
<wingo>so each compare instruction advances the ip beyond the following comparison.
<wingo>er
<wingo>following conditional branch
<wingo>also added a couple of obvious fast paths there, e.g. less_p has a nice fast path for inums, etc
<wingo>so it could be that too
<wingo>haven't pushed yet tho
<janneke>oh, that's amazing!
<wingo>hah, i create a mess and later clean it up, amazing :P :)
<janneke>that's how it goes, right :)
<wingo>hum actually that didn't help :( i was comparing numbers between two machines
<wingo>dammit :(
<ecraven>new run up: https://ecraven.github.io/r7rs-benchmarks/index.html
<rain1>thank you for making these :D
<wingo>fun :)
<stis>sneek buggs
<stis>sneek: where is bugs
<massma>hi guile, I have another pattern matching question. I'm really not sure if I'm not understanding pattern matching (I'm new to it), or if the manual doesn't match the implementation
<massma>I expected:
<massma>(match (list 0 1 2 3 "foo" "bar" "baz")
<massma> ((number ...) number)
<massma> ((number ... string ooo) string))
<massma>to return: ("foo" "bar" baz")
<massma>but it returns (0 1 2 3 "foo" "bar" "baz")
<rekado>the cases are processed in order.
<massma>but shouldn't case 1 only succeed if every element is a number?
<massma>(or case 0, rather)
<rekado>no, because “number” is just a variable
<rekado>you would need to use (? number? number) instead
<rekado>the “?” introduces a predicate, “number?” is a predicate that returns #t when the argument is a number.
<massma>I see, thanks for the clarification
<rekado>np!
<massma>do you think the manual is worth editing in match this better, or did I just really misintepret the text (very very poossible!)?
<massma>specifically where it says pattern: number // matches: a number
<rekado>yes, I do think that’s highly misleading
<massma>if so, I'm happy to make the changes, or maybe just add a note saying that the predicate patterns should be prefered
<rekado>“string”, “number”, and “character” really should be “identifier” (matches anything)
<rekado>oh, wait
<rekado>I understand now
<rekado>it does not mean “number”, but an actual number
<rekado>e.g. 42
<massma>ahhhh, yes that makes sense, and it's important and useful info to contain in the manual
<rekado>a valid match clause would be (a b 42 "hello" #\c)
<rekado>where a and b match anything, but the other three match only the exact values they represent.
<massma>got it, yeah I thought it might be my interpretation
<massma>thanks a lot for the help, appreciate it
<rekado>glad we could sort this out :)
<massma>sorry, follow up question (but if too busy feel free to ignore - I think I'm just missing something)
<massma>this returns a match error , but expected it to return ("foo" "bar" "baz"):
<massma>(match (list 0 1 2 3 "foo" "bar" "baz")
<massma> (((? number? numbers) ...) numbers)
<massma> (((? number? numbers) ... (? string? strings) ooo) strings))
<ArneBab>ecraven: thank you for the benchmarks!
<rekado>massma: “ooo” in the manual is a placeholder for “...”, “..1”, “___” (see lower in the manual)
<rekado>unfortunately, you cannot use more than one instance of “...”.
<rekado>but you could use this expression:
<rekado>(match (list 0 1 2 "foo" "bar" "baz")
<rekado> (((? number? numbers) ... (? string? a) (? string? b) (? string? c)) (list a b c)))
<massma>rekado: ahh, thanks. Does using one instance of "..." also extend to "___" "..1"?
<massma>e.g.:
<massma>(match (list 0 1 2 3 'a "foo" "bar" "baz")
<massma> (((? number? numbers) ...) numbers)
<massma> (((? number? numbers) ...
<massma> (? string? strings) ..1) strings))
<massma>does also not match
<massma>ignore 'a above - type
<massma>*typo
<massma>to clarify, the above example is probably simpler as:
<massma>(match (list 0 1 2 3 "foo" "bar" "baz")
<massma> (((? number? numbers) ...
<massma> (? string? strings) ..1) strings))
<janneke>mwette: mes+mescc runs fine with 2378e6c!
<janneke>i only needed to add char-set-copy to mes, and support for loading nyac lang sx-util
<mwette>janneke: thanks for checking -- I will make a new release in next day or two
<janneke>mwette: great! if you could add something roughly equivalent to: http://paste.debian.net/1040865/
<janneke>that would be nice; mes+mescc is very slow, some progress is nice (for now)
<janneke>this may be a temporay thing, so i'm happy to apply this patch myself...
<wingo>yeah i was wrong about reaching 2.2 perf for 3.0 interpreter (no jit), too bad
<janneke>wingo: oh well, i announced x86 guix bootstrap was done -- still hammering to build gcc-4.9 :-(
<janneke>sometimes it's easy to fool yourself, we'll get there eventually
<mwette>janneke: I may have a hack to apply from your code ; I assume that is for every reduction
<janneke>i just hacked to try and show every function definition, which with current performance strikes a sweet spot
<janneke>so anything roughly equivalent is great
<janneke>it's also nice for debugging, to have an idea where a problem occurred
<janneke>if you mean by `reduction' anything at top level, that would be nice -- every statement would be too much, of course
<janneke>for progress, it could work for debugging...
<massma>rekado: thanks for the help earlier, I get it now. In the patterns in the manual "..." correspondes to real world elipses (e.g. (pat_1 ... pat_n) => (pat_1 pat_2 etc. pat_n)), while "ooo" correspond to the match elipsi ("..." "..1" "___"), so we can only use one of "..." "..1" "__". So in the manual
<massma>" | (pat_1 ... pat_n pat_n+1 ooo) list of n or more, each element
<massma> of remainder must match pat_n+1
<massma>"
<massma>makes sense to me... as always, it was my misintepretation!
<massma>thanks!
***Guest3902 is now known as ngz
<mwette>janneke: see if the following works (outside of patching nyacc): http://paste.debian.net/1040868/
<mwette>janneke: It puts a wrapper around the actions that are listed in need-progress
<mwette>janneke: at the end of the when I forgot to put in (loop (1+ ix))
<janneke>OK
*janneke goes to test
<wingo>janneke: hehe :) commiserations and i am sure you will get it in the end :)
<ArneBab>ES6 javascript allows apply via fun(...args) — is there a way to make (fun . args) equivalent to (apply fun args) — or an argument why this is a really bad idea? It strikes me as oddly symmetric: (define (foo . args) args) (foo . args) ⇒ args
<janneke>mwette: c99-act-v and c99-len-v aren't exported...using (@@ (nyacc lang c99 parser) ...) works great for Guile -- let me try Mes (but that should work too)
<mwette>janneke: I can clean up the access.
<janneke>mwette: it works wih Mes too -- thanks!
<janneke>cleaning up access is nice, but not required
<mwette>janneke: maybe I hold off for now, I though I had it in for the other lang's
<janneke>OK -- i'm very happy that i can now drop the delta with upstream (you), and that i can update to your latest release, without patches
<janneke>and very happy with your support, removing regex because i need it for bootstrapping; thank you
<mwette>good. Still have the cond-expand for the 1.8 support. When you get a chance could you go over those and let me know if that's up to date?
<janneke>OK, will do!
<massma>(match (list 1)
<massma>oops, ignore that. thought I was at my repl :)