Hi Keith,
If it were done with some procedural macro system that represents
syntax as a special type, it could not have been tested on lists of
symbols, it would have been full of syntax->list and list->syntax
conversions in non-obvious places, and I just don't think it would
have been so much fun that I would have stayed up half the night
working on it, or finished it before morning.
I liked your example so much I decided to put in the conversions.
(define wall '#(wall)) ;; and end marker
The first change is that the table isn't syntax, but a list.
You defined the table as
(define table (syntax ((:= . 8)(or . 7) (and . 6)
(< . 5) (= . 4)(+ . 3)(* . 2))))
although it is only the identifiers are syntax-objects in
this context. (Btw - that's an example of "breaking the abstraction")
The assocations from identifiers to weights can be written directly as:
(define table `((,#':= . 8) (,#'or . 7) (,#'and . 6)
(,#'< . 5) (,#'= . 4) (,#'+ . 3) (,#'* . 2)))
or if you prefer your way better, then the a syntax->list
must be added, since table needs to be a list.
(define table (syntax->list
(syntax ((:= . 8)(or . 7) (and . 6)
(< . 5) (= . 4)(+ . 3)(* . 2)))))
These versions will work in both macro systems.
The definitions of assoid and weight requires no changes.
(define (assoid key == tab)
(let look ((tab tab))
(if (null? tab)
(begin (display (list key " not found in " table)) (newline) #f)
(if (== key (caar tab))
(cdar tab)
(look (cdr tab))))))
(define (weight op)
(if (eq? op wall)
500
(assoid op free-identifier=? table)))
The routine parse is changed to be a function which
takes a list of syntax-objects representing sub-expressions
as input.
Since parse is recursive and calls it selv with a subexpression
(which now is syntax-object) we let parse convert a syntax-objects
representing lists into lists of syntax-objects automaticcally.
I.e. the body of parse is changed from (get 10) into
(if (syntax? tokens) (parse (syntax->list tokens)) (get 10)).
Since your version uses list? and pair? to check whether a
subexpression is a compound expression, we need stx-list?
and stx-pair? when checking for compund subexpressions.
(require (lib "stx.ss" "syntax")) ; for stx-list? and stx-pair?
; parse : (list stx) -> stx
(define (parse tokens)
; this : -> stx
(define (this) (if (null? tokens) wall (car tokens)))
(define (next) (set! tokens (cdr tokens)))
(define (get greed)
(if (zero? greed)
(let ((a (this)))
(next)
(if (stx-list? (this))
(let ((arg (this)))
(next)
(list a (parse arg)))
(if (stx-pair? a) (parse a) a)))
(let ((a (get (- greed 1))))
(let more ((a a)
(op (this)))
(if (< greed (weight op))
a
(begin
(next)
(let ((b (get (- greed 1))))
(list op a (more b (this))))))))))
(if (syntax? tokens)
(parse (syntax->list tokens))
(get 10))) ; parse just primes the pump
(parse #'((1 + 2) * 3))
--
Jens Axel Søgaard
