yes i know parsing the whole code is the only portable solution, but it is slow,even on a few dozen of lines the slowing is visible ,so i can even think of that on one thousand lines...

I finally succeed in Guile with simple piece of code to make my example run with a single assignment operator <-  , here i define for variable the assignment operator <$ , <- is working with arrays too:

Preview: 

(define-syntax <$
  
  (lambda (s)
    
    (syntax-case s ()
      
      ((_ var value)
       
       (case (syntax-local-binding #'var)
	 
         ((lexical) #'(begin
			(display "<$ : lexical scope : ")
			(display (quote var))
			(newline)
			(set! var value)))
	 
	 ((displaced-lexical) #'(begin
				  (display "<$ : displaced-lexical scope : ")
				  (display (quote var))
				  (newline)
				  (set! var value)))
	 
         ((global) #'(begin
		       (display "<$ : global scope : ")
		       (display (quote var))
		       (newline)
		       (define var value)))
	 
         (else #'(begin
		   (display "<$ : unknow variable scope :")
		   (display (quote var))
		   (error "<$ : unknow variable scope : "))))))))


it allows this Scheme+ code to run with a single assignment operator (note in some case the operator is also a definition of variable,but it is invisible for the programmer, it has the duality of define and set!):

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 solution
  
  (condx [{dyn <> 0} (one? dyn)]
	 [(null? L) {dyna[ls t] <- 2}  #f] ;; return #f
	 
	 [exec {c <- (first L)}]	 
	 ;; c is the solution
	 [{c = t} {dyna[ls t] <- 1}  #t]  ;; return #t
	 
	 [exec {R <- (rest L)}]	 
	 ;; 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
			
	 ;; 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

some people were sceptic about the possibility to make it, but it works, i do not say it is portable code.

When i run the program with debug i see that:
scheme@(guile-user)> (subset-sum-guile  L-init t-init)
<$ : global scope : ls
<$ : global scope : dyn
 
<$ : global scope : c
<$ : global scope : R
<$ : global scope : s
<$ : global scope : ls
<$ : global scope : dyn
 
<$ : global scope : c
.... hundreds of lines.....
#t

all variable are global,but they are just global to the body of the function,not at toplevel,so there is no risk of breaking the code logic it is just that if we want to see lexical scope we need a more nested example,it is strange because i thought that the condx macro creates nestled code for each conditional clauses...

to see the lexical scope we can use this example:
scheme@(guile-user)>
(condx [exec {k <- 1}]
    [{k = 1} {k <- {k + 1}} {k + 1}]
    [else 'never])
<$ : global scope : k
<$ : lexical scope : k
$3 = 3
here the lexical scope is well visible :-)
but if k had existed at toplevel it is not modified :-( :
scheme@(guile-user)> (define k 0)
scheme@(guile-user)>
(condx [exec {k <- 1}]
           [{k = 1} {k <- {k + 1}} {k + 1}]
           [else 'never])
<$ : global scope : k
<$ : lexical scope : k
$4 = 3
scheme@(guile-user)> k
$5 = 0

:-(
 probably beause syntax-local-binding only works in the current lexical environment ?
https://www.gnu.org/software/guile/docs/master/guile.html/Syntax-Transformer-Helpers.html
but not at toplevel ???
Scheme Procedure: syntax-local-binding id [#:resolve-syntax-parameters?=#t]

Resolve the identifer id, a syntax object, within the current lexical environment

for this reason i still searching a solution that would be a mix of syntax-local-binding and Module System Reflection .

Damien


On Wed, Sep 22, 2021 at 8:51 PM Taylan Kammer <taylan.kammer@gmail.com> wrote:
On 22.09.2021 11:53, Damien Mattei wrote:
> i already do it this way for internal defines ,using a recursive macro that build a list of variable using an accumulator. It can works but macro expansion seems slow, it was not immediate at compilation on a little example (oh nothing more that 2 seconds) but i'm not sure it is easily maintainable, it is at the limit what macro can do i think ,for speed reasons. In fact i can not really understand in Guile as it is based on C and compiled when macro expansion happens,what is the time cost... so for all those ,perhaps not objective reason ,i prefer to avoid.

I don't think there's any other way to achieve what you want, especially
using portable Scheme code.  The lexical scoping semantics of Scheme are
a very fundamental part of the language, and cannot be worked around in
portable Scheme code without using a macro that rewrites whole bodies of
lambda expressions.

Even using implementation-specific hacks, you won't get very far.  Any
compiled Scheme implementation, and even most interpreted ones, won't
allow you to modify an outer scope's set of variable definitions from
within an inner scope.

So if you really want to have Python's scoping semantics in Scheme, you
will probably have to write a complex 'def' macro that walks through the
body and "hoists" variable definitions to the outermost scope.

If you're targeting R6RS implementations, you can use syntax-case to
write such a macro, but it won't be easy.

If you're targeting R5RS or R7RS-small implementations, you will have to
rely on syntax-rules, which will probably be extremely difficult for this
kind of complex macro.

Personally I don't even know how I would approach the problem using the
more capable syntax-case, let alone pure syntax-rules.

--
Taylan