IRC channel logs

<ArneBab>old: then I guess I won’t need psyntax — but I have an idea of just what complexity that saves me from ☺

<lisbeths>I've been thinking alot about guilemacs and I don't know a lot about the issue but here are my two cents

<lisbeths>it seems to me that org mode is a good way to incorporate multiple different languages working together in one emacs file

<lisbeths>and it seems to me that guile or any scheme could be a master system and that elisp and ielm could be a worker system

<lisbeths>this is kind of like the idea that in current day wasm if you want to get anything done you have to go through JavaScript to get it done

<lisbeths>this strategy of orchestrating guile in org mode and becoming a controller of elisp seems like trading technical debt in order to get a guile emacs faster

<lisbeths>anyway that's my thoughts thanks for reading

<cpli>humm: no, html expects genuine double quotes in style objects, it seems o-o

<humm>cpli: Even with the XML syntax for HTML?

<n|Phreak>Hello are there any books to learn guile ? I have been going throug the guile 3.0 references right now.

<humm>n|Phreak: look for books to learn Scheme and use the Texinfo manual for Guile-specific things

<n|Phreak>ok , great thanks

<ArneBab>is it in theory possible¹ to create an automatic code transformation which replaces every (import (module)) by (import (only (module) name ...))? — or (use-modules (module)) by (use-modules (module) #:select (name ...))? ¹: as in: can all info be found?

<ArneBab>While reading code, I prefer the (only ...) syntax, because that makes it possible to tell from purely local information where the different symbols come from, but while writing it is very convenient to just get the full modules until I know what I will actually use.

<ieure>ArneBab, I like using #:prefix, because that makes it clear what module a symbol came from, but you don't have to list them inidividually.

<ieure>I like a lot of stuff about traditional Lisps, but the default import everything behavior has never been one of them.

<dsmith>ArneBab, Theoretically, if `only` or `#:seelct` can find them, there must be some way for them to be found...

<ArneBab>dsmith: I worry about implicit imports for example from define-record-type. Is there a way to detect that such are included even though they are not in the written code?

<dsmith>ArneBab, I don't know the details, but a module has a hash or something in it of the exports. I *think* there is a way to iterate over that.

<dsmith>module-for-each perhaps

<dsmith>ArneBab, futures use define-record-type (module-for-each (lambda x (format #t "~s \n" x)) (resolve-module '(ice-9 futures)))

<rlb>ArneBab: I mostly just #:select now - it is a tiny bit more work, but I got used to it from clojure, where not pulling in everything became the convention early on, and found that I much preferred the benefits over the life of a codebase, both for, as you say, the obvious provenance, and for the impossibility of collisions on upgrade.

<old>rlb: why not autoload then ?

<old>if you are going to list what you need, might as well use autoload to avoid loading the module entirely until needed ?

<rlb>Hmm, never really had a situation where I thought about autoloading in guile.

<old>basically when you have circular dependencies it can help

<old>that or huge global objects

IRC channel logs

2025-04-03.log