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

[Damien Mattei <damien.mattei@gmail.com>]

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