# [plt-scheme] Re: Parsing style [Was: proof checking: a, subproblem]

Anton van Straaten wrote:
>* Scheme macros require input in s-expression form, so for anything else,
*>* you need something to transform the input syntax, even if you just
*>* transform it into s-expressions and deal with it from there. A
*>* yacc-style parser is a reasonable choice if the language you're
*>* implementing justifies it.
*>*
*>* You could, in theory, write a macro named e.g. "formula" that accepts
*>* input like the following:
*>*
*>* (formula ~(p V ~q) -> (q -> ~p A r))
*[...]
>* But with input such as the above, you'll be essentially writing a parser
*>* of your own anyway, as part of the implementation of the "formula"
*>* macro [...]
*
If you wanted such a macro, you could have the macro do just the lexing,
then let a generated parser take over. For example, using calcp from
the parser-tools examples:
(define-syntax calc
(syntax-rules ()
((calc #t () accum)
(calcp
(let ((tokens (reverse 'accum)))
(lambda ()
(if (null? tokens)
(token-EOF)
(let ((s (car tokens)))
(set! tokens (cdr tokens))
(case s
((= + - * / ^ OP CP) s)
((sin) (token-FNCT sin))
(else
(cond
((symbol? s) (token-VAR s))
((number? s) (token-NUM s)))))))))))
((calc #t ((x ...) . rest) accum)
(calc #t (OP x ... CP . rest) accum))
((calc #t (x . rest) accum)
(calc #t rest (x . accum)))
((calc . exp)
(calc #t exp ()))))
Instead of writing:
(calc (open-input-string "(1 + 2 * 3) - (1+2)*3"))
(calc (open-input-string "(x=1) x+sin(x)"))
You'd write:
(calc (1 + 2 * 3) - (1 + 2) * 3)
(calc (x = 1) x + sin(x))
[ The macro serves little purpose here beyond replacing ( and ) with OP
and CP; it could just as easily have been written as a function taking
an S-expression. ]
Does this have any benefits? Probably not.
David