Btukfyl

I'd like to compare the code contents of two syntax objects and ignore things like contexts. Is converting them to datum the only way to do so? Like:

(equal? (syntax->datum #'(x+1)) (syntax->datum #'(x+1)))

If you want to compare both objects without deconstructing them at all, then yes.

HOWEVER, the problem with this method is that it only compares the datum attached to two syntax objects, and won't actually compare their binding information.

The analogy that I've heard (from Ryan Culpepper), is this is kind of like taking two paintings, draining of them of their color, and seeing if they are identical. While they might be similar in some ways, you will miss a lot of differences from the different colors.

A better approach (although it does require some work), is to use syntax-e to destruct the syntax object into more primitive lists of syntax objects, and do this until you get identifiers (basically a syntax object whose datum is a symbol), from there, you can generally use free-identifier=? (and sometimes bound-identifier=? to see if each identifier can bind each other, and identifier-binding to compare module level identifiers.

The reason why there isn't a single simple predicate to compare two arbitrary syntax objects is because, generally, there isn't really one good definition for what makes two pieces of code equal, even if you only care about syntactic equality. For example, using the functions referenced above doesn't track internal bindings in a syntax object, so you will still get a very strict definition of what it means to be 'equal'. that is, both syntax objects have the same structure with identifiers that are either bound to the same module, or are free-identifier=?.

As such, before you use this answer, I highly recommend you take a step back and make sure this is really what you want to do. Once in a blue moon it is, but most of the time you actually are trying to solve a similar, yet simpler, problem.

Here's a concrete example of one possible way you could do the "better approach" Leif Andersen mentioned.

I have used this in multiple places for testing purposes, though if anyone wanted to use it in non-test code, they would probably want to re-visit some of the design decisions.

However, things like the equal?/recur pattern used here should be helpful no matter how you decide to define what equality means.

Some of the decisions you might want to make different choices on:

• On identifiers, do you want to check that the scopes are exactly the same (bound-identifier=?), or would you want to assume that they would be bound outside of the syntax object and check that they are bound to the same thing, even if they have different scopes (free-identifier=?)? Note that if you choose the first one, then checking the results of macro expansion will sometimes return #false because of scope differences, but if you choose the second one, then if any identifier is not bound outside of the syntax object, then it would be as if you only care about symbol=? equality on names, so it will return #true in some places where it shouldn't. I chose the first one bound-identifier=? here because for testing, a "false positive" where the test fails is better than a "false negative" where the tests succeeds in cases it shouldn't.




• On source locations, do you want to check that they are equal, or do you want to ignore them? This code ignores them because it's only for testing purposes, but if you want equality only for things which have the same source location, you might want to check that using functions like build-source-location-list.




• On syntax properties, do you want to check that they are equal, or do you want to ignore them? This code ignores them because it's only for testing purposes, but if you want to check that you might would to check that using functions like syntax-property-symbol-keys.

Finally here is the code. It may not be exactly what you want depending on how you answered the questions above. However, its structure and how it uses equal?/recur might be helpful to you.

(require rackunit)



;; Works on fully wrapped, non-wrapped, and partially

;; wrapped values, and it checks that the the inputs

;; are wrapped in all the same places. It checks scopes,

;; but it does not check source location.

(define-binary-check (check-stx=? stx=? actual expected))



;; Stx Stx -> Bool

(define (stx=? a b)

  (cond

    [(and (identifier? a) (identifier? b))

     (bound-identifier=? a b)]

    [(and (syntax? a) (syntax? b))

     (and (bound-identifier=? (datum->syntax a '||) (datum->syntax b '||))

          (stx=? (syntax-e a) (syntax-e b)))]

    [else

     (equal?/recur a b stx=?)]))