From mboxrd@z Thu Jan 1 00:00:00 1970 Path: news.gmane.io!.POSTED.blaine.gmane.org!not-for-mail From: William ML Leslie Newsgroups: gmane.lisp.guile.devel Subject: Re: new function Date: Wed, 22 Sep 2021 19:06:01 +1000 Message-ID: References: <147c2fb4-75d6-7cf6-4f4a-4edd996b0a4a@gmail.com> Mime-Version: 1.0 Content-Type: multipart/alternative; boundary="0000000000006b2b6605cc91d33a" Injection-Info: ciao.gmane.io; posting-host="blaine.gmane.org:116.202.254.214"; logging-data="35246"; mail-complaints-to="usenet@ciao.gmane.io" Cc: guile-devel To: Damien Mattei Original-X-From: guile-devel-bounces+guile-devel=m.gmane-mx.org@gnu.org Wed Sep 22 11:06:57 2021 Return-path: Envelope-to: guile-devel@m.gmane-mx.org Original-Received: from lists.gnu.org ([209.51.188.17]) by ciao.gmane.io with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.92) (envelope-from ) id 1mSyDR-0008ug-6m for guile-devel@m.gmane-mx.org; Wed, 22 Sep 2021 11:06:57 +0200 Original-Received: from localhost ([::1]:51194 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1mSyDP-00071K-9c for guile-devel@m.gmane-mx.org; Wed, 22 Sep 2021 05:06:55 -0400 Original-Received: from eggs.gnu.org ([2001:470:142:3::10]:59800) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1mSyCq-000713-EK for guile-devel@gnu.org; Wed, 22 Sep 2021 05:06:21 -0400 Original-Received: from mail-il1-x135.google.com ([2607:f8b0:4864:20::135]:34361) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1mSyCl-0005pg-PZ for guile-devel@gnu.org; Wed, 22 Sep 2021 05:06:19 -0400 Original-Received: by mail-il1-x135.google.com with SMTP id w1so2011534ilv.1 for ; Wed, 22 Sep 2021 02:06:13 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=mime-version:references:in-reply-to:from:date:message-id:subject:to :cc; bh=VDPoPQSma9Vc8Ux9HuMm2/i7qIx3ex9aEiE396q04IA=; b=aNBkXNA6rmq4GJFj8oRAcpaciuVRMAuHJWm3Pw7eYFwSRLvDmRpzj8CV9bNxbd21oi wdYoEkC9Csas11faRViONqqM3pOhfk8QdtYuQVoemPudNCNDGK8U4HF2h1qrR8nhsvGZ i+MLLqtbvtiXkrFpB2SkRBXYavJcpw35AaO/YgMYZK/X532cLmAwhr5O1XA9fuPv4RzO IINnN4awhTA2d8UpgLUBK5knVqSnokY9hE7eCmYbpXP4VmEalmL/V2uhAX5aA5zk8Z07 QUPLyK2gaBCGur0xpU3nTfEBy4Ifv5mvXDSb2VHvgsApO/bwhnG0ARqDyY7jl9TXh+nm LzbQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:mime-version:references:in-reply-to:from:date :message-id:subject:to:cc; bh=VDPoPQSma9Vc8Ux9HuMm2/i7qIx3ex9aEiE396q04IA=; b=jUnPomJjTCfKYgx4nFMqsmHSRBgDrAJo3gk4heHSYcmne7FNEVVOvQDuRNezYzLba9 qXtMsmXASUVcEtzgTJQUz/5oDGK/CYVep+XcrSq9ZZQV2LMzMDpVPzVB/1xnHB6sWLKn 9ZbYpdPHrhsEyz3HK8UGvMy0jmDoh06tc+4ZvRWxh4FaEmblMJPTgNoiKWl/G1cuoBR0 RPpl+SzzB3RpTWGPZaXiiB42W6wPtctFA/4Y6lL69n/0NWypxLWbHZTZki0mF3YB58BI 5eMP+2Ac3eTlk3GiuP6xQv2zmzhLDVYt+iyx2Ulu0Uplx5bgGAa6yqQHn03lut14mwwF WE1g== X-Gm-Message-State: AOAM530s2oFZZZ7JKDtYR8R38GfW8SkiUGwjmpXJHmM/9uTXpsRkW4Ip U1/IvhGobOuvBRCTdjB1WXa95YuK6A1gcXhe0JU= X-Google-Smtp-Source: ABdhPJxG8Wmlx76BLoGr5HOKIeyjIgxhgFGD9VZWSySJlGLtb49LkkKmpDlJ3rfVTHiKcfd748c9fIfYJRQjrt9/b4I= X-Received: by 2002:a05:6e02:20e4:: with SMTP id q4mr22653798ilv.58.1632301572892; Wed, 22 Sep 2021 02:06:12 -0700 (PDT) In-Reply-To: Received-SPF: pass client-ip=2607:f8b0:4864:20::135; envelope-from=william.leslie.ttg@gmail.com; helo=mail-il1-x135.google.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, FREEMAIL_FROM=0.001, HTML_FONT_LOW_CONTRAST=0.001, HTML_MESSAGE=0.001, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: guile-devel@gnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: "Developers list for Guile, the GNU extensibility library" List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: guile-devel-bounces+guile-devel=m.gmane-mx.org@gnu.org Original-Sender: "guile-devel" Xref: news.gmane.io gmane.lisp.guile.devel:20874 Archived-At: --0000000000006b2b6605cc91d33a Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable You could do it the same way python does it: have `def` be a macro that inspects its body for assignments to symbols, and then let-bind them at the top of the function. On Wed, 22 Sep 2021, 6:45 pm Damien Mattei, wrote= : > Hi Taylan, > > i have used Module System Reflection, and it works almost for what i > wanted to do,the only big problem is that it creates variable binding > global, seen from every where and that breaks my example code, by the way= i > will display for everybody an example of use of such a macro,so everyone > can understand the Scheme extension i want to do. I try to extend the > language, so i'm in a way construncting code from outside but not > completely, you can consider yes if you consider macro is a way to > construct code from outside in the way it expand in a new code from > another... hash table is not solution,too complex, need a global > variable... it try to make thing as simple as possible to keep speed > expansion and code up,so do not use recursive macro expansion,for now > things are fast. > > Here is a partial solving probleme solution with Module System Reflection > but i hope to be able to create local lexical scoping variable not only > global ones,because instead i will have to use 2 different assignment > operators (one replacing define and one replacing set!) and want things a= s > simple as possible and Scheme-like but Python in a function creates only > variables global to the function,i can include an option to do that too i= n > Scheme+ . > > So here is the assignment operator and an example code explaining its > caveats: > > *Preview:* > > (define-syntax <- > (syntax-rules () > ((_ var expr) (let* ((modul (current-module)) > (exist-var (module-variable modul (quote var)))) > (if exist-var > (module-set! modul (quote var) expr) > (module-define! modul (quote var) expr)))))) > > > notice that the <- operator defined above has been removed of the > arrays,vectors,etc support for readability, here i focus only on "simple" > scheme variable ,arrays,vectors is working great already. > > *Preview:* > > (define (subset-sum-guile L t) > > {ls <- (length L)} > {dyn <- dyna[ls t]} > > ;; dyna[ls][t] means 0: unknown solution, 1: solution found, 2: no solu= tion > > (condx [{dyn <> 0} (one? dyn)] > [(null? L) {dyna[ls t] <- 2} #f] ;; return #f > =09 > [exec {c <- (first L)}]=09 > ;; c is the solution > [{c =3D t} {dyna[ls t] <- 1} #t] ;; return #t > =09 > [exec {R <- (rest L)}]=09 > ;; continue searching a solution in the rest > [{c > t} {s <- (subset-sum-guile R t)} > {dyna[ls t] <- (one-two s)} > s] ;; return boolean value > =09 > ;; else : c < t at this point > ;; c is part of a solution OR not part of a solution > [else {s <- {(subset-sum-guile R {t - c}) or (subset-sum-guile R t)}} > {dyna[ls t] <- (one-two s)} > s])) ;; return boolean value > > > note that condx (conditionnal with pre execution) is just a cond allowing > to execute code before testin next condition and so on... > > here how it "compiles" in Guile Scheme+: > > scheme@(guile-user)> (load "SssDyna.scm") > ;;; note: source file > /home/mattei/Dropbox/git/library-FunctProg/SssDyna.scm > ;;; newer than compiled > /home/mattei/.cache/guile/ccache/3.0-LE-8-4.2/home/mattei/Dropbox/git/lib= rary-FunctProg/SssDyna.scm.go > ;;; note: auto-compilation is enabled, set GUILE_AUTO_COMPILE=3D0 > ;;; or pass the --no-auto-compile argument to disable. > ;;; compiling /home/mattei/Dropbox/git/library-FunctProg/SssDyna.scm > ;;; SssDyna.scm:73:8: warning: possibly unbound variable `array-ref-set!' > ;;; SssDyna.scm:192:28: warning: possibly unbound variable `=C2=A7' > ;;; SssDyna.scm:400:2: warning: possibly unbound variable `dyn' > ;;; SssDyna.scm:408:10: warning: possibly unbound variable `dyn' > ;;; SssDyna.scm:408:21: warning: possibly unbound variable `dyn' > ;;; SssDyna.scm:411:15: warning: possibly unbound variable `c' > ;;; SssDyna.scm:413:10: warning: possibly unbound variable `c' > ;;; SssDyna.scm:415:15: warning: possibly unbound variable `R' > ;;; SssDyna.scm:417:10: warning: possibly unbound variable `c' > ;;; SssDyna.scm:417:24: warning: possibly unbound variable `R' > ;;; SssDyna.scm:417:24: warning: possibly unbound variable `R' > ;;; SssDyna.scm:417:18: warning: possibly unbound variable `s' > ;;; SssDyna.scm:418:33: warning: possibly unbound variable `s' > ;;; SssDyna.scm:408:2: warning: possibly unbound variable `s' > ;;; SssDyna.scm:423:22: warning: possibly unbound variable `R' > ;;; SssDyna.scm:423:42: warning: possibly unbound variable `c' > ;;; SssDyna.scm:423:54: warning: possibly unbound variable `R' > ;;; SssDyna.scm:423:22: warning: possibly unbound variable `R' > ;;; SssDyna.scm:423:42: warning: possibly unbound variable `c' > ;;; SssDyna.scm:423:54: warning: possibly unbound variable `R' > ;;; SssDyna.scm:423:15: warning: possibly unbound variable `s' > ;;; SssDyna.scm:424:30: warning: possibly unbound variable `s' > ;;; SssDyna.scm:408:2: warning: possibly unbound variable `s' > ;;; compiled > /home/mattei/.cache/guile/ccache/3.0-LE-8-4.2/home/mattei/Dropbox/git/lib= rary-FunctProg/SssDyna.scm.go > > it compiles well, you will notice that variables seems unbound to compile= r > because they are created *dynamically* by the macro of <- operator but > that is not a problem. > > They create well but they create globally. > > i ran the test code example like this: > (define L-init '(1 3 4 16 17 24 45 64 197 256 275 323 540 723 889 915 104= 0 > 1041 1093 1099 1111 1284 1344 1520 2027 2500 2734 3000 3267 3610 4285 502= 7)) > > (define t-init 35267) > > (define ls (length L-init)) > > (define dyna (make-array 0 {ls + 1} {t-init + 1})) > > (define (one-two b) > (if b 1 2)) > it search if exist a solution to the subset sum problem on the list L-ini= t > with sum being 35267, > there exist such a solution so the return answer must be #t. > > with global definitions the return value is wrong (#f) because variables > are created globallly. > the problem is in those lines: > [exec {R <- (rest L)}] > will assign (rest L) to R, but R is a global variable! ,R must be local t= o > function, it is worse than Python because <- create toplevel variables !!= !, > and then when i execute: > [else {s <- {(subset-sum-guile R {t - c}) or (subset-sum-guile R t)}} > the first clause of or run well: (subset-sum-guile R {t - c}) > but modify R as it is not a local variable and then the second clause of > or: (subset-sum-guile R t) return wrong result because it is called with = R > containing a bad value: > (subset-sum-guile L-init t-init) > #f > scheme@(guile-user)> R > () > R exist now at top-level !!! > > the solution to make the code run well in this case was just to create a > local variables,using another assignment operator <+ that add a local > variable in local lexical scope the way define do it: > [exec {R <- (rest L)}] is equivalent to [exec (define R (rest L))] > and then the code succeed again and return #t value. > > So i want now to have by default a lexical scope for <- and new variables > to be local to the nested block ,not global, even not local to function (= as > in Python) even if in this particuliar example code would have run well > with local scoping. (but note that if <- is called on an already existing > variable of a different scope,upper or global,or top-level, i want ot be > able to set! it) > I want to be able to control the scoping of variables so i can make this > assignment operator the way i want,and also propose different assignment > operators with different variable scope. > > Damien > > > On Sun, Sep 19, 2021 at 11:39 PM Taylan Kammer > wrote: > >> On 19.09.2021 09:54, Damien Mattei wrote: >> > hello, >> > i'm developing an extension to Scheme >> > and i need a procedure or macro that define a variable only if it is >> not bind and if it is just set! it. >> > >> > I can not do it in Guile or any Scheme,and i'm desperately searching a >> way to do that. I finally conclude that it can be done only by adding it= in >> the language. >> > >> > Can someone include a such function in Guile next release? >> > i know guile have a predicate defined? to test binfing of a vairable >> but writing a macro with it is not possible because define can be used i= n >> an expression context. >> > >> > Thank in advance for any help >> > Damien >> >> What is the utility of such a function? Since Scheme is lexically scope= d, >> it's generally obvious whether a variable has already been defined or no= t, >> rendering such an operation useless. >> >> If you're constructing code from outside input so that you don't know >> whether a provided variable name represents a variable that's already be= en >> defined or not, then you could use the module reflection API: >> >> >> https://www.gnu.org/software/guile/manual/html_node/Module-System-Reflec= tion.html >> >> Sounds like 'module-define!' does exactly what you ask for. I wonder wh= at >> exactly your use-case is though. Chances are that your use-case is best >> served with a simple data structure like a hash table... >> >> -- >> Taylan >> > --0000000000006b2b6605cc91d33a Content-Type: text/html; charset="UTF-8" Content-Transfer-Encoding: quoted-printable
You could do it the same way python does it: have `def` b= e a macro that inspects its body for assignments to symbols, and then let-b= ind them at the top of the function.

On Wed, 22 Sep 2021, 6:45 pm Damien Mat= tei, <damien.mattei@gmail.com= > wrote:
Hi Ta= ylan,

i have used Module = System Reflection, and it works almost for what i wanted to do,the only big= problem is that it creates variable binding global, seen from every where = and that breaks my example code, by the way i will display for everybody an= example of use of such a macro,so everyone can understand the Scheme exten= sion i want to do. I try to extend the language, so i'm in a way constr= uncting code from outside but not completely, you can consider yes if you c= onsider macro is a way to construct code from outside in the way it expand = in a new code from another... hash table is not solution,too complex, need = a global variable... it try to make thing as simple as possible to keep spe= ed expansion and code up,so do not use recursive macro expansion,for now th= ings are fast.

Here i= s a partial solving probleme solution with Module System Reflection but i h= ope to be able to create local lexical scoping variable not only global one= s,because instead i will have to use 2 different assignment operators (one = replacing define and one replacing set!) and want things as simple as possi= ble and Scheme-like but Python in a function creates only variables global = to the function,i can include an option to do that too in Scheme+ .

So here is the assignment oper= ator and an example code explaining its caveats:

Preview:

=20 
(define-syntax <-
  (syntax-rules ()
    ((_ var expr) (let* ((modul (current-=
module))
			 (exist-var (mo=
dule-variable modul (quote =
var))))
		    (if exist-var
			(module-set! modul (quote var) expr)
			(module-define! modul (<=
span style=3D"color:rgb(251,102,10);font-weight:bold">quote var) expr))))))
=20
=


notice that the <- operator defi= ned above has been removed of the arrays,vectors,etc support for readabilit= y, here i focus only on "simple" scheme variable ,arrays,vectors = is working great already.

Preview= :

=20 
(define (subset-sum-guile L =
t)

  {ls <- (length L)}
  {dyn <- <=
span style=3D"color:rgb(251,102,10)">dyna[ls t]}
 =20
  ;; dyna[ls][t] means 0: unknown solution, 1: solution found, 2: =
no solution
 =20
  (condx [{dyn <> 0} (one? dyn)]
	 [(null? L) =
{dyna[ls t] <- 2}  #f] ;; return #f
	=20
	 [exec {c <- (first L)}]	=20
	 ;; c is the solution
	 [{c =3D t} {dyna[ls t] <- 1}  #t]  ;; return #t
	=20
	 [exec {R <- (rest L)}]	=20
	 ;; continue searching a solution in the rest
	 [{c > t} {s &=
lt;- (subset-sum-guile R t=
)}
	          {dyna[ls t] <- (on=
e-two s)}
		  s] ;; return boolean value
		=09
	 ;; else : c < t at this point
	 ;; c is part of a solution OR not part of a solution
	 [else {s <- =
{(subset-sum-g=
uile R {t - c}) or (subset-sum-guile R<=
/span> t)}}
	       {dyna[ls t] <- (one-t=
wo s)}
	       s])) ;; return boolean value
=20

= note that condx (conditionnal with pre execution) is just a cond allowing t= o execute code before testin next condition and so on...

here how it "compiles" in Guile Scheme+:

scheme@(guile-user)> (load &quo= t;SssDyna.scm")
;;; note: source file /home/mattei/Dropbox/git/libr= ary-FunctProg/SssDyna.scm
;;; =C2=A0 =C2=A0 =C2=A0 newer than compiled /= home/mattei/.cache/guile/ccache/3.0-LE-8-4.2/home/mattei/Dropbox/git/librar= y-FunctProg/SssDyna.scm.go
;;; note: auto-compilation is enabled, set GU= ILE_AUTO_COMPILE=3D0
;;; =C2=A0 =C2=A0 =C2=A0 or pass the --no-auto-comp= ile argument to disable.
;;; compiling /home/mattei/Dropbox/git/library-= FunctProg/SssDyna.scm
;;; SssDyna.scm:73:8: warning: possibly unbound va= riable `array-ref-set!'
;;; SssDyna.scm:192:28: warning: possibly un= bound variable `=C2=A7'
;;; SssDyna.scm:400:2: warning: possibly unb= ound variable `dyn'
;;; SssDyna.scm:408:10: warning: possibly unboun= d variable `dyn'
;;; SssDyna.scm:408:21: warning: possibly unbound v= ariable `dyn'
;;; SssDyna.scm:411:15: warning: possibly unbound vari= able `c'
;;; SssDyna.scm:413:10: warning: possibly unbound variable = `c'
;;; SssDyna.scm:415:15: warning: possibly unbound variable `R= 9;
;;; SssDyna.scm:417:10: warning: possibly unbound variable `c';;; SssDyna.scm:417:24: warning: possibly unbound variable `R'
;;; = SssDyna.scm:417:24: warning: possibly unbound variable `R'
;;; SssDy= na.scm:417:18: warning: possibly unbound variable `s'
;;; SssDyna.sc= m:418:33: warning: possibly unbound variable `s'
;;; SssDyna.scm:408= :2: warning: possibly unbound variable `s'
;;; SssDyna.scm:423:22: w= arning: possibly unbound variable `R'
;;; SssDyna.scm:423:42: warnin= g: possibly unbound variable `c'
;;; SssDyna.scm:423:54: warning: po= ssibly unbound variable `R'
;;; SssDyna.scm:423:22: warning: possibl= y unbound variable `R'
;;; SssDyna.scm:423:42: warning: possibly unb= ound variable `c'
;;; SssDyna.scm:423:54: warning: possibly unbound = variable `R'
;;; SssDyna.scm:423:15: warning: possibly unbound varia= ble `s'
;;; SssDyna.scm:424:30: warning: possibly unbound variable `= s'
;;; SssDyna.scm:408:2: warning: possibly unbound variable `s'=
;;; compiled /home/mattei/.cache/guile/ccache/3.0-LE-8-4.2/home/mattei/= Dropbox/git/library-FunctProg/SssDyna.scm.go

it compiles well, you will notice that variables seems unbound to compil= er because they are created dynamically by the macro=C2=A0 of <- = operator but that is not a problem.

They create well but they create globally.

i ran the test code example like this:
(define L-init '(1= 3 4 16 17 24 45 64 197 256 275 323 540 723 889 915 1040 1041 1093 1099 111= 1 1284 1344 1520 2027 2500 2734 3000 3267 3610 4285 5027))

(define t= -init 35267)

(define ls (length L-init))

(define dyna (make-a= rray 0 {ls + 1} {t-init + 1}))

(define (one-two b)
=C2=A0 (if b 1= 2))
it search if exist a solution to the subs= et sum problem on the list L-init with sum being 35267,
there exist such a solution so the= return answer must be #t.

with global definitions the return value is wrong (#f) because variables = are created globallly.
the problem is in those lines:
[exec {R <- (rest L)}]
will assign (rest L) to R, but R is a gl= obal variable! ,R must be local to function, it is worse than Python becaus= e <- create toplevel variables !!!, and then when i execute:
[else {s <- {(subset-su= m-guile R {t - c}) or (subset-sum-guile R t)}}
the first clause of or run well: (subset-su= m-guile R {t - c})
but modify R as it is not a local variable and then the second clause o= f or: (subset-sum-guile R t) return wrong result because it is called with = R containing a bad value:
(subset-sum-guile =C2=A0L-init t-init)
#f
scheme@(guile-user)> R
()
R exist now at top-level !!!

the solution to make the c= ode run well in this case was just to create a local variables,using anothe= r assignment operator <+ that add a local variable in local lexical scop= e the way define do it:
[exec {R <- (rest L)}] is equivalent to [exec (define R (rest L= ))]
and then th= e code succeed again and return #t value.

So i want now to have by default a lexical scope for <= ;- and new variables to be local to the nested block ,not global, even not = local to function (as in Python) even if in this particuliar example code w= ould have run well with local scoping. (but note that if <- is called on= an already existing variable of a different scope,upper or global,or top-l= evel, i want ot be able to set! it)
I want to be able to control the scoping of variab= les so i can make this assignment operator the way i want,and also propose = different assignment operators with different variable scope.

Damien


= On Sun, Sep 19, 2021 at 11:39 PM Taylan Kammer <taylan.kammer@gmail= .com> wrote:
On 19.09.2021 09:54, Damien Mattei wrote:
> hello,
> i'm developing an extension to Scheme
> and i need a procedure or macro that define a variable only if it is n= ot bind and if it is just set! it.
>
> I can not do it in Guile or any Scheme,and i'm desperately searchi= ng a way to do that. I finally conclude that it can be done only by adding = it in the language.
>
> Can someone include a such function in Guile next release?
> i know guile have a predicate defined? to test binfing of a vairable b= ut writing a macro with it is not possible because define can be used in an= expression context.
>
> Thank in advance for any help
> Damien

What is the utility of such a function?=C2=A0 Since Scheme is lexically sco= ped,
it's generally obvious whether a variable has already been defined or n= ot,
rendering such an operation useless.

If you're constructing code from outside input so that you don't kn= ow
whether a provided variable name represents a variable that's already b= een
defined or not, then you could use the module reflection API:

https://= www.gnu.org/software/guile/manual/html_node/Module-System-Reflection.html

Sounds like 'module-define!' does exactly what you ask for.=C2=A0 I= wonder what
exactly your use-case is though.=C2=A0 Chances are that your use-case is be= st
served with a simple data structure like a hash table...

--
Taylan
--0000000000006b2b6605cc91d33a--