IRC channel logs


back to list of logs

***X-Scale` is now known as X-Scale
***daviid` is now known as daviid
***dostoevsky6 is now known as dostoevsky
***sneek_ is now known as sneek
***Furor is now known as Colere
***rgherdt_ is now known as rgherdt
***X-Scale` is now known as X-Scale
***X-Scale` is now known as X-Scale
<alextee[m]>someone is getting this when executing a guile script:
<alextee[m]>ERROR: In procedure apply-smob/1: Throw to key decoding-error' with args ("scm_from_stringn" "input locale conversion error" 22 #vu8(47 104 111 109 101 47 109 111 111 110 119 97 108 107 101 114 47 46 99 97 99 104 101 47 112 97 114 117 47 99 108 111 110 101 47 122 114 121 116 104 109 47 115 114 99 47 122 114 121 116 104 109 45 49 46 48 46 48 45 98 101 116 97 46 50 46 48 46 51 47 98 117 105 108 100 47 114 101 115 111 117 114 99 101 115 47 122 114 121 116 104
<alextee[m]>109 46 103 114 101 115 111 117 114 99 101 115 46 120 109 108))'.
<alextee[m]>any ideas what could be causing this?
<alextee[m]>apparently `guile -v` shows that error too
<civodul>alextee[m]: hi! could it be you're running in a C or otherwise ASCII locale?
<civodul>is the current directory name non-ASCII?
*alextee[m] asks
<dsmith-work>{appropriate time} Greetings, Guilers
<chrislck>daviid: why are internal defines "bad" (genuine qu)??? they do keep code tidy
***civodul` is now known as civodul
<tohoyn>do the generics eqv? and equal? always return #f for two different GOOPS classes?
<tohoyn>If I have two GOOPS classes <a> and <b> is it correct to define method equal? (or eqv?) with arguments <a> and <b>?
<tohoyn>^for instances of two different GOOPS classes
<tohoyn>^with arguemnt types <a> and <b>
<Zambyte>Hi, kind of a weird question, but is there a way to maintain square brackets when printing quoted expresions?
<Zambyte>`(display '(let [x 5] x))` and `(pretty-print '(let [x 5] x))` both print `(let (x 5) x)`
<Zambyte>`(read-disable 'square-brackets)` leads to some very not pretty output: `(pretty-print '(let [x 5] x))` => `(let #{\x5b;x}# #{5\x5d;}# x)`
<mwette>chrislck: consider (define a 1) (letrec ((b a) (a 10)) a), then replace with internal defines, in the same order. What should you get? (Try replacing letrec with let*.)
<mwette>meant to say (define a 1) (letrec ((b a) (a 10)) b)
<mwette>i.e., ends in b) not a)
<mwette>Ah! Internal define semantics is explained in the guile ref manual, sec 6.10.3. So, at least well defined for guile.
<mwette>Internal defines have letrec* binding semantics.
<dthompson>I have a kind of expensive procedure (a small compiler of sorts) that I want to run when my module is compiled (the solution is known then, no info needed at runtime) and have the result (a string) stored in the compiled object file. I feel like it should be possible, guile is quite flexible, but I'm not sure what I should be doing. :) anyone know?
<dthompson>something something syntax-case??
<dsmith-work>dthompson: Look into eval-when
<dthompson>I have looked into it but it has never behaved in the way I thought it would.
<dsmith-work>Do you have a cat?
<dthompson>lol yeah?
<dsmith-work>Need to be cautious. See the last line in the above link...
<dthompson>oh I'll have to be very careful indeed
<dthompson>well it does seem that a little syntax-case magic will work
<dthompson>I feel like there might be a simpler way to get there but this works...
<daviid>dthompson: i think that (eval-when (expand) (run-my-compiler)) should do it (though i don't bear responsibility if it poisoned your cat :), untested here)
<daviid>or (eval-when (compile) (run-my-compiler)) - with what you wrote above, this might be sufficient
<daviid>dthompson: fwiw, the only s/w i know that uses a 'none recommended (none poisoning) :)' subset of eval-when valid conditions is guile-gnome, in corba, to init gnome corba, it calls, in (gnome corba), (eval-when (load eval) (%init-gnome-corba)), which definitely works(worked, long time not tested) as expected
<dthompson>for whatever reason, even after reading the documentation page several times, eval-when just doesn't click with me! I don't know what it is lol
<dthompson>I'll tinker with it and see if I can use it instead of syntax-case
<daviid>dthompson: it's ok, if uyou try, let me know how it goes, tx
<daviid>dthompson: did you ever tried the goops patch i wrote wrt slot-unbound?
<daviid>i completely forgot to send it ...
<daviid>i was waiting for yourfeedback, then forgot :)
<dthompson>uhhhh I honestly don't remember... that was a long time ago
<dthompson>I haven't done much with guile in over 6 months. just getting back into it.
<daviid>ok, if you can try it, let me know, i'll send the patch to bug-guile
<dthompson>I'd have to go hunting for it
<daviid>ah, no worries then, i can send it as isi think, i also have to dig in to find the patch here:):)
<jab>Guile Steel!
<drakonis>guile steel indeed.
<jab>cwebber: guile steel may be interested in this:
<jab>It's a systems language that's rather lispy built on top of LLVM.
<jab>cwebber: it competes against Odin, V, and Zig
<jab>cwebber: the repo is a bit light in documentation. He's got a ton of videos no youtube though.
<cwebber>jab: that does look interesting
<cwebber>> The language is expression-based, but primarily imperative. The syntactical style marries concepts from Scheme and Python, describing source code with S-expressions but delimiting blocks by indentation rather than braces.
<cwebber>sounds wispy
<cwebber>ArneBab: ^^
<drakonis>guile steel needs the interactive bits...
<drakonis>though the interactive bits require support, since you cant bolt it into generic scheme code and expect it to run
<cwebber>looks like scopes has a REPL
<jab>cwebber: So actually, when you watch the youtube videos, you can write code use s-expressions.
<cwebber>jab: oh interesting
<jab>He just allows by default to not have them.
<cwebber>also wispy :)
<jab>drakonis: what are the interactive bits?
<cwebber>I still think there's a good reason to have such a thing *in guile*
<cwebber>but this could be a source of inspiration
<jab>cwebber: I think the best solution should be to use the guile tower!
<cwebber>jab: oh I *absolutely* agree
<cwebber>but this *does* look interesting and thank you for linking me to it
<cwebber>dthompson: btw, fun aside
<cwebber>I have a reason to sketch up a little twine-like interactive fiction game which doesn't really have state
<cwebber>is more like a choose-your-own-adventure
<drakonis>jab: a good debugging ui like cl's i'd say
<cwebber>it struck me suddenly that Haunt would actually be perfect for this
<drakonis>debugging guile is not fun
<cwebber>which also is a very drakonis topic too, haha
<jab>dthompson: how hard would it be to make emacs an optional dependancy of Haunt? That way we could use Emacs to render org documents in Haunt...
<jab>drakonis: good debugging would be nice!
<cwebber>jab: jakob l. kreuze made an org-mode exporter that he sent directly to dthompson and I
<cwebber>he called it a kluge though
<cwebber>I should drag it up again
<jab>cwebber: you might be able to persuade me to pay you to include it in the next release....
<dthompson>cwebber: so like you click on links in a haunt site to progress instead of turning to specific pages?
<dthompson>jab: it wouldn't be that hard but I don't know if I really want to do it. it's already possible for someone to define their own reader that shells out to emacs to parse .org filse
<dthompson>but it's kind of messy: whatever org-mode exports would need to be parsed again to get it into sxml format
<cwebber>dthompson: yup
<cwebber>and some things on-page might be able to have some nice on-page details
<dthompson>and if org-mode is adding header/foot type stuff, then you have to dig in and find the subset of the document that you actually want
<cwebber>like looking at an object could just have a little css hover-over description
<dthompson>cwebber: sounds like a fun idea to me
<cwebber>dthompson: btw, there's an org-mode exporter that just exports an sexp AST
<dthompson>that would be the better way to go probably
<dthompson>still need a second hop to translate to sxml but that's fine
<cwebber>hm, maybe it doesn't exist anymore
<dthompson>at the risk of simultaneous topic overload... here's a brief example of why I was asking about doing compile-time computation earlier: OpenGL shaders represented using s-expressions!
<cwebber>oh right
<cwebber>jab: another fun option, you could take the above and write a nice guile-org-mode package
<cwebber>which has a parser :)
<cwebber>or somethin
<dthompson>I would add built-in org-mode integration to haunt if there was a guile library that did all the parsing and didn't require shelling out
<cwebber>the texinfo stuff could probably be looked at
<cwebber>as an inspiration
<dthompson>markdown has been good enough for me for blog posts so I don't have a personal itch to scratch
<cwebber>it's probably not worth it to me either but actually this is cool
<cwebber>could probably be translated to guile's peg parser
<jab>cwebber: I appreciate the info that you've given me! My main project right now is getting openstmpd working a little better in guix system land
<cwebber>jab: worthwhile goal
<jab>cwebber: I feel like I need to finish that before I do what you suggested.
<jab>Just out of curiosity dthompson or cwebber or anyone else, how much would you charge to make it so that I could use org-mode in haunt? Even if it meant adding in an /contrib directory to Haunt so that users could shell out to Emacs...
<cwebber>jab: you don't need to change anything in haunt
<cwebber>you can add your own importer easily
<cwebber>without changing haunt itself
<jab>For mm, I might pay $100.
<cwebber>jab: one trick would be to export to html from org-mode
<cwebber>unfortunately I lack time more than anything right now :)
<cwebber>but you could shell out to emacs to export to html
<cwebber>and then use the guile-lib htmlprag library to import
<jab>cwebber: gotcha. How about if I said $1 billion ? jab puts his pinkie towards his mouth....
<cwebber>jab: I'd definitely do it for a billion, but if you said 1 billion, I would doubt your sincerity greatly :)
<cwebber>but if you do have 1 billion to spare then sure, the nonprofit I'm starting definitely could use cash in that level of magnitude, we're even a 501c3 tax-exempt charity :)
<cwebber>so you could write it off even!
<jab>cwebber: that's actually my point. You could include in the Haunt source code an /contrib/ directory. Then add in some custom shell script and maybe some elisp code that lets you use org-mode.
<jab>cwebber: I usually donate $100 to FSF each year. Why should I donate to your profit instead? I really do like your non-profit by the way. :)
<jab>dthompson: who has made some cool games with chickadee?
<cwebber>jab: well you already said you like it :)
<cwebber>one reason is that we're an institution that's putting our bets on Guile :)
<cwebber>and we're trying to save the internet
<cwebber> there's a paypal link there
<cwebber>other donate options will be available soon
<jab>cwebber: like is the understatement of the year.
<dthompson>jab: I currently have no time to take on paid work outside of my full time job. :) I could point you in the right direction for writing your own "reader" (that's what we call a thing that parse a post in haunt) that shells out to emacs, though
<dthompson>jab: I haven't seen anyone besides myself actually release a game that was made with chickadee. I've released two games that were made during game jams.
<dthompson>the one I'm most proud of is my most recent jam entry: Bonnie Bee
<dthompson>it's a vertical scrolling shooter. I made all the assets and wrote all the code. it's short and has a little boss fight at the end.
<dthompson>someone made a flappy bird clone, too
<jab>dthompson: I think cwebber sent some resources my way. but I am happy to see the link you would provide about how to write my own reader that shells out to emacs
<jab>dthompson: have you ever considered trying to make $$ with your games? Copyright the assets for a year or so, but release the source code as free software?
<jab>You could maybe sell said game via elementary OS
<dthompson>jab: I haven't really considered it because making a game that people would pay money for is quite difficult.
<dthompson>and it would be even more difficult to do it "my way" without serious compromises along the way
<dthompson>most mainstream platforms simply don't allow free software games for starters.
<dthompson>I wouldn't be comfortable with releasing something that had proprietary assets, either.
<jab>dthompson: elementary OS would be ok with that.