current community

your communities

more stack exchange communities

Stack Exchange
tour help
careers 2.0
Take the 2-minute tour ×
Stack Overflow is a question and answer site for professional and enthusiast programmers. It's 100% free, no registration required.
up vote 0 down vote favorite

This R5RS macro is what I have tried and is pretty much what I want to do. Racket or other implementations don't like this macro exactly where I wanted the magic to happen.

(define-syntax quote-unique
  (syntax-rules (magic end)

    ;; end case
    ((quote-unique magic processed end)
     'processed)

    ;; finished iteration
    ((quote-unique magic (processed ...) sym1 end rest ... )
     (quote-unique magic (processed ... sym1) rest ... end))

    ;; match (doesn't work since racket doesn't like sym1 twice in template)
    ;; but I'm looking for the same expression twice
    ((quote-unique magic processed sym1 sym1 . rest )
     (quote-unique magic processed sym1 . rest))

    ;; rotate
    ((quote-unique magic processed sym1 sym2 rest ... )
     (quote-unique magic processed sym1 rest ... sym2))

    ;; start iteration
    ((quote-unique rest ...)
     (quote-unique magic () rest ... end))))

This would have been easy in Common Lisp:

(defmacro quote-unique ( &rest xs )
  (labels ((remove-duplicates (lis)
        (if lis
        (if (member (car lis) (cdr lis))
                (remove-duplicates (cdr lis))
            (cons (car lis) (remove-duplicates (cdr lis)))))))

     (list 'quote (remove-duplicates xs))))

I also have been reading Define syntax primer and think the implementation of is-eqv? would have pointed me in the right directions, but it seems it's not a macro that is defined there.

If it's not possible in R5RS compile time, how could this be done with R6RS?

share|improve this question
add comment

1 Answer

up vote 1 down vote accepted

You can't do this using syntax-rules, but you can do it using syntax-case, by using a guard that uses free-identifier=?. Here's an example:

(define-syntax (remove-id stx)
  (syntax-case stx ()
    ((_ head ())
     #''())
    ((_ head (next tail ...)) (free-identifier=? #'head #'next)
     #'(remove-id head (tail ...)))
    ((_ head (next tail ...))
     #'(cons 'next (remove-id head (tail ...))))))

> (remove-id foo (foo bar baz qux foo bar))
; => (bar baz qux bar)

But of course, if you're going to use syntax-case, there's a much simpler way to implement your quote-unique (this implementation uses Racket's custom hashtables):

(require (for-syntax racket/dict))
(define-syntax (quote-unique stx)
  (define (id-dict ids)
    (foldl (lambda (id d)
             (dict-set d id #t))
           (make-immutable-custom-hash free-identifier=? (compose eq-hash-code syntax-e))
           (syntax-e ids)))
  (syntax-case stx ()
    ((_ ids ...)
     (with-syntax ((unique (dict-keys (id-dict #'(ids ...)))))
       #''unique))))
share|improve this answer
add comment

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.