Re: new function

[Maxime Devos]

Damien Mattei schreef op do 23-09-2021 om 19:27 [+0200]:
> 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,

No, they are local, even though syntax-local-binding returns 'global'.
'syntax-local-binding' doesn't know we will be defining a local variable
with the same name later, so it says 'global' instead of 'lexical' or
'displaced-lexical'.

There is no such thing as ‘global to the body of the function’, what you are
descrbing is local variables.

The macro <$ you have defined won't work for the "hello world" example I sent
you:

(define (#{hello/won't-work}# language)
  (cond ((equal? language "dutch")
         (<$ message "Hallo wereld"))
        ((equal? language "english")
         (<$ message "Hello world")))
  (display message)
  (newline))
While compiling expression:
Syntax error:
unknown file:70:9: definition in expression context, where definitions are not 
allowed, in form (define message "Hallo wereld")

The following does, however:

(define (hello language)
  (<$ message #f)
  (cond ((equal? language "dutch")
         (<$ message "Hallo wereld"))
        ((equal? language "english")
         (<$ message "Hello world")))
  (display message)
  (newline))

Possibly this limitation of <$ is acceptable to you though.

> 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 .

Use the second return value of syntax-local-binding.
Or just use set! instead of <$ and <- to modify global variables,
and use <- and <$ for local variables only.

Greetings,
Maxime.

signature.asc
Description: This is a digitally signed message part