A lexical use-modules?

A lexical use-modules?

[Maxime Devos]

[-- Attachment #1: Type: text/plain, Size: 1539 bytes --]

Hi,

[ CC'ing guix-devel@ because this functionality could be useful in Guix
package definitions ]

Currently, use-modules cannot be meaningfully used inside procedures,
unless '(current-module)' is always the module in which the procedure
is defined.

I wondered if some kind of 'lexical use-modules' was possible, with
sufficient macroology and module reflection, and it looks like it is:

(use-modules (srfi srfi-1))
(define-syntax use-module/lexical
  ;; todo: integrate into (use-modules ...)?
  (lambda (s)
    (syntax-case s ()
      ((_ foo)
       (let* ((module-name (syntax->datum #'foo))
              (interface (resolve-interface module-name)))
         (define (binding->import name variable)
           (define name-syntax (datum->syntax s name))
           #`(define-syntax #,name-syntax (identifier-syntax (@ foo
#,(datum->syntax #'irrelevant name)))))
         #`(begin #,@(module-map binding->import interface)))))))

(define &exception 'top-level)
(let ()
  (use-module/lexical (ice-9 exceptions))
  (pk 'inner &exception raise-continuable))
;;; (inner #<record-type &exception> #<procedure raise-continuable (obj)>)

(pk 'outer &exception)
;;; (outer top-level)

(pk 'unbound-variable raise-continuable)
;; a backtrace!

Limitation: things like

(define (foo)
  (use-module/lexical (platform-specific-constants))
  (if on-linux?
      CONSTANT_ONLY_DEFINED_ON_LINUX
      CONSTANT_ONLY_DEFINED_ON_HURD))

won't work in cross-compilation contexts.

Greetings,
Maxime.

[-- Attachment #2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 260 bytes --]

Re: A lexical use-modules?

[Ludovic Courtès]

Hi,

Maxime Devos <maximedevos@telenet.be> skribis:

> I wondered if some kind of 'lexical use-modules' was possible, with
> sufficient macroology and module reflection, and it looks like it is:

I agree it would be useful.

Just yesterday wrote this (my goal here was to allow dynamic module
loading based on some condition);

--8<---------------cut here---------------start------------->8---
(define-syntax with-modules
  (syntax-rules ()
    "Dynamically load the given MODULEs at run time, making the chosen
bindings available within the lexical scope of BODY."
    ((_ ((module #:select (bindings ...)) rest ...) body ...)
     (let* ((iface (resolve-interface 'module))
            (bindings (module-ref iface 'bindings))
            ...)
       (with-modules (rest ...) body ...)))
    ((_ () body ...)
     (begin body ...))))
--8<---------------cut here---------------end--------------->8---

… which can be used like this:

--8<---------------cut here---------------start------------->8---
(with-modules (((fibers) #:select (spawn-fiber sleep))
               ((fibers channels)
                #:select (make-channel put-message get-message)))
  (let ((channel (make-channel)))
    (spawn-fiber
      …)))
--8<---------------cut here---------------end--------------->8---

Unlike ‘use-modules’, its clearly limited to the lexical scope of its
body.

IWBN to have a similar functionality in Guile proper, and it could
probably be made more efficient.

Ludo’.

Re: A lexical use-modules?

[Maxime Devos]

[-- Attachment #1: Type: text/plain, Size: 904 bytes --]

Maxime Devos schreef op za 26-03-2022 om 20:21 [+0100]:
> (define-syntax use-module/lexical
>   ;; todo: integrate into (use-modules ...)?
>   (lambda (s)
>     (syntax-case s ()
>       ((_ foo)
>        (let* ((module-name (syntax->datum #'foo))
>               (interface (resolve-interface module-name)))
>          (define (binding->import name variable)
>            (define name-syntax (datum->syntax s name))
>            #`(define-syntax #,name-syntax (identifier-syntax (@ foo
> #,(datum->syntax #'irrelevant name)))))
>          #`(begin #,@(module-map binding->import interface)))))))

This probably does not interact perfectly with 'syntax-parameterize',
'bound-identifier=?'/'free-identifier=?' and 'syntax-local-binding',
though I guess it is good enough for most practical purposes.

Greetings,
MAxime.

[-- Attachment #2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 260 bytes --]