adding #' syntax and my cloned macro no more works like original....

[Damien Mattei]

hello,

i having a little horrific bug in one of my macro. In fact i have 2 macro :
<- that do all the job and another alias ←

till now the ← acted as a perfect clone of <- wihtout having all the code,
being defined as:

(define-syntax ← ;; under Linux this symbol can be typed with the
   ;; combination of keys: Ctrl-Shift-u 2190 where 2190 is the unicode of
left arrow

   (syntax-rules ()

     ((_ var ...) (<- var ...))))

but now that i added a few 'syntax' to <- , i have errors using ← , some
bindings become unbinded:

error is sort of :

ice-9/boot-9.scm:1685:16: In procedure raise-exception:
Unbound variable: lin

Entering a new prompt.  Type `,bt' for a backtrace or `,q' to continue.
scheme@(guile-user) [1]> ,q

appearing in:

{iepi[{lin + 1} 0] ← vct-prime-implicants[lin]}

if i replace it with:

{iepi[{lin + 1} 0] <- vct-prime-implicants[lin]}

all works again.

backtrace is of no help, sort of:
scheme@(guile-user) [1]> ,bt
In /Users/mattei/library-FunctProg/guile/logiki+.scm:
  2848:18  5 (_ #<continuation 1073b2380>)
   743:23  4 (infix-symb-min-dnf _)
  1777:41  3 (minimal-dnf _)
  2707:38  2 (_ _)
  2546:18  1 (identify-essential-prime-implicants _ _)
In ice-9/boot-9.scm:
  1685:16  0 (raise-exception _ #:continuable? _)

i know it is a macro problem, not in procedures,and it is since i added
some #' syntax to optimize code...

a solution would be to duplicate all the code from <- into ← but this is
stupid.

how can i change ← to act perfectly as <- ?

i'm afraid to post it but i think i must post the code of <- to get any
help about that:

;; {s <+ (string-append "abcdefgh")};; "abcdefgh";; > {s[2 * 3 - 4 $ 2
* 3 + 1 $ 2 * 4 - 6] <- "0000"};; "ab0d0f0h"
;; $bracket-apply$ is from SRFI 105  bracket-apply is an argument of
the macro(define-syntax <-

  (lambda (stx)

    (syntax-case stx ()


      ;; silly case
      ((_ ( ) expr)
       #'(void)) ;; void is not portable ;'())

      ;; one value in values !
      ;; > {(x) <- (values 7)}
      ;; > x
      ;; 7
      ((_ (var) expr)

       #'(set!-values-plus (var) expr))



      ;; example: {a[4] <- 7}
      ;; $bracket-apply$ is from SRFI 105  bracket-apply is an
argument of the macro

      ((_ (brket-applynext container index ...) expr)  ; possible to
have NO index :
                                        ; minimal form is (_ (brket-applynext 
container) expr)

       ;; We will let the second $bracket-apply$ be executed and
forbid the execution of first $bracket-apply$.
       (cond ((equal? (quote $bracket-apply$next) (syntax->datum
#'brket-applynext))  ;; already parsed and optimised by parser

              #'(assignmentnext container expr index  ...)) ; possible to have 
NO index


             ;; integrated curly-infix of guile (no parsing) at REPL
             ((equal? (quote $bracket-apply$) (syntax->datum #'brket-applynext))

              (display "<- : (syntax->datum #'(index ...)) = ") (display
(syntax->datum #'(index ...))) (newline)
              (display "<- : (number? (car (syntax->datum #'(index ...)))) =
") (display (number? (car (syntax->datum #'(index ...))))) (newline)
        
              ;; parse arguments at posteriori here:
              (with-syntax ((parsed-args (datum->syntax stx ; #f
                                                        (cons #'list
                                                              
(optimizer-parse-square-brackets-arguments-lister
(syntax->datum #'(index ...)))))))
                           (display "<- : #'parsed-args=") (display 
#'parsed-args) (newline)
                           (display "<- :  (syntax->datum #'parsed-args)=") 
(display
(syntax->datum #'parsed-args)) (newline)
        
                           ;;(case (length (syntax->datum #'(index ...)))
                           (case (length (cdr (syntax->datum #'parsed-args)))

                             ;; 0 argument in []
                             ;; T[]
                             ;; {v[] <- #(1 2 3)}
                             ;; > v
                             ;;'#(1 2 3)
                             ((0)
                              #'(assignment-argument-0 container expr))  ; 
possible to have NO index

                             ;; 1 argument in [ ]
                             ;; T[index]
                             ((1)
                              #'(assignment-argument-1 container
                                                       (first parsed-args)
                                                       expr))

                             ;; 2 arguments in [ ]
                             ;; ex: T[i1 :] , T[: i2], T[i1 i2] , T[: :]
                             ;; {#(1 2 3 4 5)[inexact->exact(floor(2.7)) :]}
                             ;; '#(3 4 5)
                             ((2)
                              #'(assignment-argument-2 container
                                                       (first parsed-args)
                                                       (second parsed-args)
                                                       expr))

                             ;; 3 arguments in [ ]
                             ;; T[i1 : i2] , T[i1 i2 i3] , T[: : s]
                             ((3)
                              #'(assignment-argument-3 container                
                        
                                                       (first parsed-args)
                                                       (second parsed-args)
                                                       (third parsed-args)
                                                       expr))
                        
                             ;; 4 arguments in [ ]
                             ;; T[: i2 : s] , T[i1 : : s] , T[i1 : i3 :] , T[i1 
i2 i3 i4]
                             ((4)
                              #'(assignment-argument-4 container
                                                       (first parsed-args)
                                                       (second parsed-args)
                                                       (third parsed-args)
                                                       (fourth parsed-args)
                                                       expr))

                             ;; 5 arguments in [ ]
                             ;; T[i1 : i3 : s] , T[i1 i2 i3 i4 i5]
                             ((5)
                              #'(assignment-argument-5 container
                                                       (first parsed-args)
                                                       (second parsed-args)
                                                       (third parsed-args)
                                                       (fourth parsed-args)
                                                       (fifth parsed-args)
                                                       expr))

                             ;; more than 5 arguments in [ ]
                             ;; T[i1 i2 i3 i4 i5 i6 ...]
                             (else ; case
                              #'(assignment-argument-6-and-more container 
parsed-args expr)))))

             (else ; cond
              #'(set!-values-plus (brket-applynext container index ...)
expr)))) ; warning: the argument's names does not match the use



      ;;(<- x 5)
      ((_ var expr)

       #'(set! var expr))


      ;; (declare x y z t)
      ;; {x <- y <- z <- t <- 7}
      ;; 7
      ;; (list x y z t)
      ;; (7 7 7 7)

      ;; > (require srfi/25)
      ;; > {I <- (make-array (shape 0 4 0 4))}
      ;; #<array:srfi-9-record-type-descriptor>
      ;; > {I[0 0] <- I[1 1] <- I[2 2] <- I[3 3] <- 1}
      ;; 1
      ;; > {I[0 0]}
      ;; 1
      ;; > {I[0 1]}
      ;; 0
      ;; > I
      ;; #<array:srfi-9-record-type-descriptor>

      ;; > (declare a b c d)
      ;; > {(a b) <- (c d) <- (values 5 7)}
      ;; > a
      ;; 5
      ;; > b
      ;; 7
      ;; > c
      ;; 5
      ;; > d
      ;; 7

      ;; without declare:
      ;; > {(a b) <- (c d) <- (values 5 7)}
      ;; > (list a b c d)
      ;; '(5 7 5 7)
      ((_ var var1 ... expr)


       #'(begin ;; i do not do what the syntax says (assignation not
in the good order) but it gives the same result
           ;;(display "<- : case (_ var var1 ... expr)") (newline)
        
           (define return-values-of-expr (create-return-values expr))
           (<- var (return-values-of-expr))
           ;;(display "<- : case : passed (<- var expr)") (newline)
           ;;(display "<- : case : var=") (display var) (newline)
        
           (<- var1 (return-values-of-expr))
           ...))


      )))




Best regards,
Damien