IRC channel logs

<daviid>cmhobbs: anyway, it is not normal, if you successfully compiled installed guile-gnome, that the (gnome-2) module is not present in (%global-site-dir)

<daviid>cmhobbs: carefully read and apply all the steps here https://www.gnu.org/software/guile-gnome/download.html

<daviid>cmhobbs: installing guile-gnome is a piece of cake, imo, not a mess :)

<daviid>going afk for a bit, ping me if you still face problems

<cmhobbs>davexunit: guile-gtk was the mess. guile-gnome was pretty straightforward (via the readme, anyway). i'll try from the site instructions

<djcb>i'd like my c program to start the guile-shell (that part works), but also with a bit of guile run before the user gets to the repl

<djcb>is there some nicer(?) way than manipulating the argv passed to scm_boot_guile?

<Sleep_Walker>can I set something so guile will silently update existing *.go file when it exists already but is older than *.scm source? :)

<random-nick>if you mean for autocompilation, guile already checks for old cache entries

<ArneBab_>wingo: I get compile errors with 2.1.3: ;;; ERROR: Throw to key `match-error' with args `("match" "no matching pattern" #<cps (kargs () () (continue 1829 (prompt #t 3882 1827)))>)'.

<ArneBab_>wingo: this is the file: https://bpaste.net/show/3a780d59f59c

<ArneBab_>wingo: it works flawlessly with 2.0.11

<nalaginrut>ArneBab_: wingo I can get similar exception with (while #t (continue)), it's fine in 2.0

<nalaginrut>and I've reported a bug

<nalaginrut>this bug prevent me to implement 'continue' in for loop as extension syntax of guile-lua

<nalaginrut>s/extension/extended

<Sleep_Walker>random-nick: yes, I was asking, if it can check silently :)

<random-nick>Sleep_Walker: it does check but only in the autocompilation cache

<random-nick>Sleep_Walker: if it's older than the source it recompiles

<Sleep_Walker>and informs me about that

<ruste>davexunit: https://rbryan.github.io/posts/guile-lips-scheme-as-a-generic-macro-language.html

<ruste>Wrote it up.

<dsmith-work>Morning Greetings, Guilers

<ruste>Morning dsmith-work o/

<wingo>meep

<ruste>wingo: road runner?

<wingo>just some kind of sound

<brendyn>When is guile scheduled to take over the world?

<ruste>Ah, meep to you too then.

<davexunit>brendyn: next week or so.

<davexunit>ruste: I see that you're on the HN front page. congrats!

<ruste>davexunit: Thanks! I think I've got another project coming along that may do well too!

<brendyn>I got some good practice with Emacs today. Is Guile with Emacs expected to succeed one day or is it to overwhelming of a project/

<wingo>i think it will succeed but it's a bit contingent at this point

<wingo>it needs a champion :)

<brendyn>wingo: Are you someone that does everything in Emacs?

<ruste>wingo: You're doing a fine job of that. Your work brought me here!

<ruste>Oh, thought we were talking about guile. blah, emacs.

<ruste>nvm.

<brendyn>What does success look like for guile

<brendyn>Does wingo intend to pull a Racket and deviate from RnRS?

<brendyn>I saw you were in disagreement about some R7RS things I didn't understand.

<wingo>i think success looks like growth :) growth in user base and growth of the language to incorporate the strengths of ML, erlang, racket, clojure, etc

<wingo>regarding rnrs there is for better or for worse no such thing; the revisions relate to each other but do not describe the same language

<brendyn>I'm trying to learn but it's so painful to figure anything out. So many basic things there are command-line tools for that I can't figure out in scheme.

<davexunit>just takes time to learn

<ruste>It does. To be honest, I tried and failed to get into scheme a few times before it stuck.

<ruste>I still learn new things ever day.

<wingo>guile will probably not deviate from r5rs. probably with r6rs we will remain mostly compatible and actually ever-more compatible

<davexunit>guile has my become my go-to language for any problem when I can choose the language the solution is written in

<wingo>but probably we also add a --r6rs flag

<wingo>and an --r7rs flag

<wingo>but we will probably not implement r7rs-small by default unless the --r7rs flag is passed

<wingo>that is my guess

<ruste>wingo: That sounds similar to what racket is doing with it's language features.

<ruste>Where you just put the language you'll be using at the top of the file.

<wingo>ruste: yeah. i tried to float the idea of #lang in guile a couple years ago but it didn't stick; maybe it could work now ;)

<wingo>i really like the #lang mechanism

<ruste>I kind of like that, especially if more languages are going to be implemented on top of the guile vm.

<ruste>I'd be cool with it.

<brendyn>I don't really understand the difference between Racket & Guile philosophy-wise

<ruste>davexunit: Same here.

<brendyn>or technically-wise

<wingo>brendyn: me neither :) we are in the same space in many ways.

<brendyn>The Awesome Scheme

<wingo>well

<brendyn>It seems that everyone writes their own Scheme implementation

<brendyn>I was looking for a Scheme->Javascript the other day and found about 30 implementations, all from 2013 or before

<wingo>racket isn't a scheme any more, it's more of a programming language programming language -- which i think is a great aspiration for guile too

<wingo>in some ways they have better support for embedding programming languages though. in some ways guile does things differently and perhaps better? dunno

<brendyn>0.o

<wingo>anyway, better to see racket and guile as siblings that are less in competition with each other than the world of non-schemey-people

<wingo>in some alternate universe, rms blessed mzscheme instead of scm :P

<brendyn>Sure, it's just as a greedy customer, I'd like everyone working together on a common project than fragmented.

<wingo>dunno. i have never written any racket on purpose. i am going to soon tho just to see how it is

<wingo>i read a lot of their code and papers of course :)

<davexunit>brendyn: monoculture isn't healthy. :)

<brendyn>Sure

<wingo>davexunit: works for clojure tho ;)

<davexunit>this is true

<dsmith-work>ijp: About lua. ISTR something about it needing a peg parser?

<davexunit>I dunno, I just like Guile. Racket is cool, too, but I'll stick with Guile.

<davexunit>there are some significant differences between the two in philosophy

<brendyn>Any recommendations for learning more guile? My issue is I never have personal coding projects to work on

<davexunit>I believe someone in the Racket world once said "the top-level is dead"

<davexunit>alluding to Racket being more in the "static" camp than Guile

<davexunit>which I think leads to differences in how a Racket REPL works vs. a Guile REPL

<brendyn>Or my ideas are too difficult. I'd like to learn how to write some kind of learning algorithm to parse Chinese into words, and then map them onto English words/phrases to make a word-for-word/phrase kind of translator

<brendyn>top-level?

<davexunit>top-level environments

<davexunit>where there is no parent scope environment

<ruste>I know when I was first starting out the biggest selling point for guile in my mind was that it just worked the way I expected it to.

<brendyn>I don't have any expectations to begin with

<ruste>The next biggest one was that it was minimal and small compared to racket. It didn't come with its own IDE.

<ruste>brendyn: I'm talking more about being able to run things at the command line like guile stuff.scm

<ruste>And having a directory that it looks for modules in.

<ruste>I had a heck of a time trying to get common lisp to work the way I expected.

<ruste>Guild just worked.

<brendyn>I thought it was quite bizarre getting guile scripts working

<ruste>brendyn: To each his own. :)

<brendyn>Having to do #!/usr/bin/guile \\ --no-auto-compile -e main -s !#

<ruste>brendyn: If you're looking for projects to work on you should look at project euler to learn or maybe adding library bindings for guile to common libraries.

<brendyn>Could you link me to an example

<ruste>brendyn: For linking to libraries?

<brendyn>Yeah, I've never done it before

<ruste> https://dthompson.us/pages/software/guile-sdl2.html

<ruste>davexunit has done some good ones.

<ruste>Another major selling point for me on guile. The FFI is really really easy to use and you don't need to write any C.

<wingo>did anyone have thoughts on kaction's declarative FFI module submitted to guile-devel recently?

<wingo>greets paroneayea

<ruste>wingo: Having only glanced at the documentation patch I like it.

<wingo>ACTION nod

<wingo>i haven't looked at it seriously yet

<ruste>The symbols for denoting types feel a bit common lispy though.

<ruste>With the colons.

<ruste>I'd just have regular symbols like 'long, 'string etc or I'd have #:string #:long

<ruste>That would feel more guiley to me.

<ruste>In my uneducated opinion.

<ruste>The :: for return type feels pretty natural to me though.

<paroneayea>hi wingo

<paroneayea>wingo: I'm back in guile network application hacking again

<paroneayea>so I probably will look at the stuff you've done with the guile and async stuff later this week

<amz3>hello :)

<wingo>paroneayea: cool :)

<wingo>i have been thinking about it too, there are some more features that guile needs...

<wingo>like if you have a nonblocking socket-backed port that gets gc'd, guile shouldn't try to flush writes on it

<wingo>and guile should somehow remove auxiliary information from the user-space scheduler when an fd is closed, either via an explicit close-port invocation or via gc

<wingo>with epoll, closing an fd automatically removes it from the epoll set

<wingo>but there is still an auxiliary structure listing what fibers are waiting on what port, i guess

<ruste>Strangely specific quit message that.

<quigonjinn>What function should I apply to a list, to evaluate to null?

<dsmith-work>quigonjinn: null?

<quigonjinn>an empty list

<dsmith-work>scheme@(guile-user)> (null? '())

<dsmith-work>$1 = #t

<quigonjinn>I have a list, with a random number of elements, and I need to get a list with none

<dsmith-work>scheme@(guile-user) [1]> (define the-list '())

<dsmith-work>scheme@(guile-user) [1]> (apply (lambda () '()) the-list)

<dsmith-work>$2 = ()

<dsmith-work>Sorry

<dsmith-work>scheme@(guile-user)> (define the-list '(a b c d))

<dsmith-work>scheme@(guile-user)> (apply (lambda x '()) the-list)

<dsmith-work>$1 = ()

<quigonjinn>dsmith-work: thanks! this worked with my code

<galex-713>:()

<defanor>does guile-gtk work with guile 2?

<defanor>(looks like it does not, just asking to be sure)

<galex-713>I thought it did :o why wouldn’t it work?

<defanor> https://www.gnu.org/software/guile/libraries/ says it's for guile 1.8, and apparently it wasn't updated since 2007. did you try it with guile 2?

<jmd>defanor: FYI there is G-Golf - But it is rather immature at the moment.

<defanor>jmd: will check it, thanks

<mark_weaver>defanor: guile-gnome replaces guile-gtk

<galex-713>ah ok I thought they said guile-gtk like the gtk module from guile-gnome

<random-nick>why do people use --no-autocompile in scripts?

<defanor>mark_weaver: apparently that's what i need, then. thanks

<paroneayea>wingo: you were the one who wrote most of the current web modules' design right? I've always been curious on the rationale for separating "request" and "request-body" as two separate objects/arguments being passed around

<ruste>wingo: I'm also interested in the web modules. How would one go about implementing https support for them? You could pretty easily link to an outside library, but that would add a dependency for guile. The only way I can think to do it is to write a separate package with bindings to ssl and point users to that. It seem useful enough that it should come with the web modules though...

IRC channel logs

2016-08-01.log