R7RS does not support underscore as a keyword in syntax-rules

[ar-nelson]

In other R7RS schemes, it is possible to define a keyword named _ in syntax-rules, and that keyword will be detected in pattern matching. Gerbil appears to always reserve _ as a wildcard, even if it has been named as a keyword.

For example, this script underscore-keyword.scm:

(import (scheme base)
        (scheme write))

(define-syntax is-underscore
  (syntax-rules (_)
    ((is-underscore _) #t)
    ((is-underscore x) #f)))

(display (list (is-underscore _) (is-underscore 1)))
(newline)

Gauche and Chibi match the first case when passed the literal symbol _, and the second case otherwise; they print (#t #f). But Gerbil treats the _ as a wildcard and always matches the first case; it prints (#t #t).

$ gosh -r7 underscore-keyword.scm
(#t #f)
$ chibi-scheme underscore-keyword.scm
(#t #f)
$ gxi --lang r7rs underscore-keyword.scm
(#t #t)

[vyzo]

I don't think that behaviour is specified in the standard though.
_ goes deep in gerbil, it's recognized as the "ignore/wildcard" identifier in many forms.

[vyzo]

Also note that there is a predicate bound at phi=1 which you can use to test for underscores: underscore?.

[ar-nelson]

@vyzo I don't think it is either--actually, when I CTRL-F the R7RS document for _, it looks like it doesn't even describe its usage as a wildcard in syntax-rules patterns, even though every Scheme does that.

But there's good reason to support using _ as a keyword: what if you want to define your own syntax that uses _ as a wildcard? In this case, I had a macro for my own pattern-matching syntax on top of R7RS, and I had to take out the _ wildcard case to make it compile in Gerbil. There's probably a way to make this work using cond-expand and underscore?, but that's just another Gerbil-specific kludge in the codebase.

[vyzo]

There is no need for much trickery, you can use a fender in the syntax-rules pattern.
For instance:

(defrules is-underscore? ()
  ((_ x) (underscore? #'x) #t)
  ((_ x) #f)))

[vyzo]

Btw, why don't you just use the native match on Gerbil?
It is well tuned and compiler optimized.

[ar-nelson]

@vyzo Because I'm writing an application in R7RS so that it can be portable to as many platforms as possible, and as many Schemes as possible. I don't want to use any Gerbil-specific features in the portable parts of the code.

I'm not using Gerbil for Gerbil's syntax, I'm using it because it's an R7RS Scheme that compiles to fast native code.

[vyzo]

That's totally fine, Gerbi is a meta-language after all.
You could however cond-expand and use the native gerbil match when appropriate, it probably has similar syntax to your match (or could be molded to do so with the macro capabiities), and you'd get faster pattern matching optimized by the compiler.