IRC channel logs


back to list of logs

<mark_weaver>but actually, if you use 'open-input-pipe' or 'open-pipe*', I don't see why you should have to fork yourself. the pipe procedures take care of that for you.
<bananagram>I have primitive-fork but not open-input-pipe etc
<bananagram>and I don't know C fork
<mark_weaver>e.g. 'open-input-pipe' makes the pipe, forks off a new process, and then runs the command you specified within that subprocess.
<dsmith-work>bananagram: Do you mean your platform doesn't have fork, and so the pipe stuff is unimplemented?
<bananagram>dsmith-work: yes
<bananagram>is it a CPU thing or OS thing, or do I need to compile it with fork?
<dsmith-work>What platform?
<bananagram>arch, 32-bit, with a little pentium
<bananagram>arch linux
<dsmith-work>Hs fork
<bananagram>but my guile doesn't have it
<dsmith-work>Did you compile it yourself?
<dsmith-work>Did you include the popen module?
<dsmith-work>(use-modules (ice-9 popen))
<bananagram>yes, it doesn't exist
<bananagram>I was using ice9, not ice-9
<bananagram>nvm, thanks
<dsmith-work>Later on, Guileers. Happy Hacking.
<handheldCar>having trouble getting libgc* 6.8 to work for the bdw-gc 6.8 configure requirement
<mark_weaver>you should really use libgc-7.2d
<handheldCar>ok, no problem
<davexunit>evening everyone
<davexunit>mark_weaver: hey. I'm taking a look at how to hack my own repl server with the new repl code.
<mark_weaver>davexunit: should be the same except without having to propagate *repl-stack*
<mark_weaver>(a nice simplification)
<mark_weaver>hi bananagram!
<mark_weaver>going offline for a while.. ttyl!
<dsmith>Hey hey
<davexunit>I now have a functioning REPL server. A server whose clients start REPLs that run as coroutines within guile-2d's event loop.
<davexunit>what do you all think about making (system repl server) a bit more generic?
<davexunit>I hacked this module for my own purposes, and I realized that I only changed one procedure: serve-client
<handheldCar>configure said readline too old, need 2.1 or later. 6.1 installed from system install
<dsmith>handheldCar, What about the -dev package?
<handheldCar>thanks, that's a possibility
<handheldCar>that was it.
<dsmith>handheldCar, You always have to think about how does ./configure know you have some library installed or not. And usually it's by the header or the pkg-config file. And those are only in the -dev packages.
<aidalgol>Is there a way to get the path of the file from which the current procedure was loaded?
<aidalgol>Or for a module that has been loaded?
*aidalgol is implementing per-bot log files.
<ijp>aidalgol: are you using the logger in spells?
<aidalgol>uh, no...
<aidalgol>How do I compile the documentation header comments with the @ directives in them?
<aidalgol>In spells.
<aidalgol>Because trying to read it inline is not pleasant.
<ijp>you know, I've never tried
<aidalgol>I s'pose I should bug rotty directly, then.
<ijp>btw, there's a bug in (default-logger-properties), see if you can spot it :)
<aidalgol>lambda isn't unquoted?
<aidalgol>*the lambda
<ijp>ding ding ding
<ijp>I have a pull request to fix that, but it's been, let's see....
<ijp> least a year
<aidalgol>Uh... huh...
<aidalgol>Is rotty dead?
<ijp>not as of january
<ijp>but could be
<aidalgol>Bug aside, that logging library seems overkill for this.
<aidalgol>Take a look at the 'logging' branch and tell me what you think of what I have so far.
<ijp>I've never seen a logging library that didn't look like overkill
<aidalgol>What are you, birny?
*ijp flays aidalgol for force pushing
<aidalgol>Gah! You noticed!
<ijp>well, it's an improvement
<ijp>heh, it's quite amusing that 'Software Foundations' comes as a valid coq file
<aidalgol>How so?
<ijp>that's literally how it's distributed
<ijp>for each section you get a html page and a .v file that the html was generated from
<ijp>which actually makes it really convenient to read from emacs
<aidalgol>ijp: How do you load/unload plugins, again?
<ijp>(use-plugin! bot 'plugin-name)
<ijp>and remove-plugin! to remove
<aidalgol>No more need for register-command! ?
<ijp>I'd keep it around for one-offs
<aidalgol>Should we put any of run-cbot.scm in the library itself (bot.scm) ?
<ijp>I'm not sure
<aidalgol>It still feels a little clumsy.
<ijp>I think it would be nice to have a fancy procedure/macro for creating them
<ijp>but I'm not sure what it should look like
<ijp>I have some ideas, I'll maybe push one to a branch later
<aidalgol>Oh, good! This is what I keep fiddling with instead of setting up an instance, and am not getting anywhere.
<aidalgol>You work on that; I'll work on the logging.
<ijp>civodul: you've used proof general? how do I get it to stop interfering with buffer switching?
<ijp>like if I C-x b in my *goals* window, it will move to the window with the .v, and then switch that one
<stis>evening folks!
<stis>ijp: I fanally managed to get delimeted continuations fro guile-log, kanren and prolog correct, phue!
<ijp>I've just been wrestling with coq and proof general all day
<stis>Bin there done that. No I would like to transfer that to guile-log, think of using all cool constructs on proof search
<stis>actually delimited continuations for prolog is right on the resaearch front right now,
<stis>from 2013!
<stis>And their continuations are not first class!!
<ijp>well, I can't even imagine how that should work with relational programs
<ijp>of course, my imagination does not limit reality
<stis>Ijp, it's really not easy to combine them with interleaving construts.
<stis>pure kanren can't support it and you need a more advanced version of guarded variables .
<ijp>yes, but I was thinking more about going in the reverse direction
<ijp>perhaps we can implement a "come from" as an april fools :)
<stis>reverse direction?
<ijp>e.g. (+o a b 3)
<ijp>if you think of functions of computations, then you are reversing it from an argument to an answer
<ijp>of functions as*
<ijp>answer to an argument*
<stis>yes I'm more found of values then out arguments, but I managed quite well to implement this.
<ijp>gah, time to go raking through the bowels of 'git reflog'
<stis>cool, happy hacking!
<ijp>not hacking, data recovery :)
<stis>oh, not so cool, but keep up the happiness still if you can ;-)
<ijp>phew, I think that's everything
*stis cheers!
<ijp>"system/repl/server.scm:64:0: Error while printing exception." my favourite error
<ijp>right after the "too many errors" error
<stis>haha, yea error reporting is not gule's strength.
<ijp>in this case it was because I passed in a keyword argument without the keyword :(
<stis>ijp: You are complaining about lua's parser, checkout my prolog parser, to se a hopefully sane one!
<ijp>unless it parses lua, it's not going to do me any good :)
<stis>No, but I use a operator parser framework e.g. you just configure it and it parses expressions.
<stis>I used it for a C parser as well to parse C expressions
<stis>It also shows a pattern to borrow from.
<ijp>I know how to write a parser
<stis>But I bet there is better references for suchj tools then guile-log
<ijp>I might be hitting an optimizer bug
<ijp>I have some code that works correctly when I wrap a particular expression with 'pk', but now when I remove it
<ijp>but not*
<ijp>oh wow
<ijp>it optimizes away a mutable variable that depends on function arguments
<ijp>that's not just broken, but terribroken
<ijp>that pun probably works better for the east asians who are currently asleep and not on the channel
<ijp>okay, I have a smallish example
<ijp>even though the value of l depends on the input, it gets optimized away to '()
*ijp grumbles, and mails the tracker
<ijp>aidalgol: morning
<ijp>aidalgol: I've been distracted from the bot by optimizer bugs!
<aidalgol>Help, I'm being oppressed!
<aidalgol>I mean, Hi!
<ijp>so now that I know it isn't my fault, I need to rewrite this code
<stis>ijp 2.0.5 does not have this bug. A bisect shoule be possible.
<ijp>bisecting is a pain because I have tweaks to the that always give me trouble
<ijp>it basically means a full build every time :(
<aidalgol>ijp: Fun fun fun!
<aidalgol>I didn't know you worked on Guile at that level.
<ijp>I don't really
<ijp>cunning-bot: lets
<cunning-bot>Let's embrace nihilism enthusiastically.
<ijp>cunning-bot: shoot aidalgol
<cunning-bot>Wrong type argument in position 1: (vector (quote ("shotgun" . "blasts")) (quote ("ICBM silo" . "nukes")) (quote ("water gun" . "drenches")) (quote ("flame thrower" . "roasts")) (quote ("tranquilizer gun" . "knocks out")) (quote ("taser" . "electrocutes")) (quote ("Colt Peacemaker" . "pacifies")) (quote ("RFC1149-compliant avian carrier" . "UDP floods")) (quote ("Batarang" . "knocks %s down")) (quote ("shell" . "fork b
<ijp>le sigh
<ijp>aidalgol: check the sugar branch
<ijp>right now 'bot' is a procedure using keyword arguments, but it would be better to make it a macro I think
<ijp>and remember to pull the changes from master this time -_-
<aidalgol>Mmm, syntactic sugar.
<aidalgol>So, as a macro newb, why a macro instead of a function?
<ijp>aidalgol: the keyword approach is nice, but keywords are always optional
<ijp>you can throw an error, from the body, but it isn't the same
<aidalgol>How would a macro solve this?
<ijp>because then we can check for it at expansion time
<aidalgol>OK, you'll have to show me. This is outside my knowledge of macros.
<aidalgol>Hmm. looks like I fucked up the firearms transition.
<ijp>it's not an important difference at the moment anyway
<mark_weaver>ijp: that's a nasty bug that you just reported. it happens on stable-2.0 as well :-(
<ijp>it's funny that a bug that hides itself appeared so close to my thompson bug blogpost :)
<mark_weaver>how does the bug hide itself?
<ijp>when I pk, it isn't there
<mark_weaver>we really ought to document pk :)
<ijp>aidalgol: pk (or peek) is just a function that prints out a value and then returns it
<mark_weaver>it actually prints out all of its arguments, and then returns the last one. so it's quite useful to wrap around expressions whose values you want to see, usually prefixed by a literal symbol or string (as a label)
<mark_weaver>e.g. (some-expression) => (pk 'blah (some-expression))
<aidalgol>I've been MUDding too much, because I saw "pk" and thought "player-kill(er|ing)".
<add^_>aidalgol: :-)
<mark_weaver>ijp: well, the problem is in peval. it removes the 'l' from the call to 'apply'.
<mark_weaver>and then no doubt a later pass removes 'l' entirely, which at this point is justifiable.
<ijp>well, I haven't looked much into the peval code, but it seems to me that it must have not been seeing the set!
<mark_weaver>I haven't looked at peval much either.. maybe it's time to start :)
<ijp>I read it back when civodul added it, but then wingo started adding all these counters :)
<ijp>on a slight tangent, I read the syntax case chapter from 'beautiful code', and it was surprisingly simple
<ArneBab>sneek: later tell davexunit that it would be really cool, if guile-2d were installable from guix (along with all dependencies).
<sneek>Will do.
<ArneBab>sneek: later tell davexunit or at least with all the dependencies which are not in debian.
<sneek>Will do.
<ArneBab>sneek: botsnack
<bananagram>sneek: hi
<bananagram>sneek: help
<bananagram>sneek: who is sneek
<sneek>From what I understand, sneek is a good boy
<ijp>pfft, so you say
<civodul>ijp: i don't remember having problems with ProofGeneral
<sneek>Welcome back civodul, you have 4 messages.
<sneek>civodul, mark_weaver says: I've used '@' to reference macros, even a few days ago, and it always seems to work for me.
<sneek>civodul, mark_weaver says: e.g. ((@ (guile) define) (foo x y) (+ x y)) (foo 2 3) => 5
<sneek>civodul, mark_weaver says: afaict, it even works for primitive syntactic keywords that aren't macros, e.g. ((@ (guile) @) (ice-9 local-eval) local-eval) => #<procedure local-eval (x e)>
<sneek>civodul, mark_weaver says: and ((@ (guile) quote) (1 2)) => (1 2)
<civodul>that was a couple of years ago tho
<ijp>civodul: I nearly died of shock when it opened a new *frame*
<civodul>oh, i can understand :-)
<civodul>dunno, i don't remember going through that
<civodul>mark_weaver: hmm you seem to be right (re macros)
<civodul>i do remember having problems (getting a raw syntax-transformer object), but i can't come up with a test case
<ArneBab>sneek: later tell davexunit Here’s a patch to include installation instructions for Gentoo:
<sneek>Got it.
<ArneBab>sneek: later tell davexunit The examples/images folder misses sprite.png (from
<sneek>Got it.
<ArneBab>sneek: botsnack
<youlysse`>What would a skribilo file best be licensed as -- under the GFDL?
<civodul>youlysse`: funnily, you don't really have the choice: it must be GPLv3-compatible
<civodul>in theory at least
<youlysse`>Well -- that make it easy at least. :^I
<civodul>because technically, a Skribilo document is a program that uses Skribilo as a library
<civodul>i need to ask licensing@ about that
<ArneBab>sneek: later tell davexunit: A patch to get examples/scenes.scm running:
<sneek>Will do.
<ArneBab>civodul: doesn’t Skribilo have a linking exceptions?
<civodul>no, but maybe it should
<ArneBab>sneek: later tell davexunit: How does guile-2d handle it, if it cannot realize a timestep of 1/60th of a second?
<ArneBab>sneek: later tell davexunit: What I really liked in pyglet was that every step of the game-loop got a dt parameter which contained the time since the last step. That allows for physically realistic behaviour.
<sneek>Got it.
<ArneBab>sneek: botsnack