Перезапуск продолжения схемы в странном месте
ОБНОВИТЬ:
Таким образом, проблема, похоже, связана с генератором, а не обязательно с функциями next-token и lookahead. Я добавил несколько экранных вызовов, где происходили set! S, и обнаружил, что проблема в том, что после того, как (generate-token) вызывается во второй раз, он возобновляет выполнение с того места, где он был вызван в первый раз.
Вот полный код программы (я оставил исходный пост ниже для справки):
(define char-alphanumeric? (lambda (char) (or (char-alphabetic? char) (char-numeric? char))))
(define generate-token #f)
(define filename "input.txt")
(define next-token #f)
(define lookahead #f)
(define status #f)
(let ((f (open-input-file filename)) (yield #f) (token "") (lookahead-token #f) (current-token #f))
(set! generate-token (lambda ()
(letrec ((next-char (lambda (c)
(let ((separators (list #\; #\,)))
(cond ((eof-object? c) (display "last token before eof: ") (display token) (newline) (yield c))
((member c separators)
(begin
(display "token before sep: ") (display token) (newline)
(call-with-current-continuation (lambda (resume)
(set! generate-token (lambda () (resume)))
(yield token)))
(display "back from call") (set! token "")
(call-with-current-continuation (lambda (resume)
(set! generate-token (lambda () (resume)))
(yield (make-string 1 c))))
))
((or (char-alphanumeric? c) (equal? c #\_)) ; c is part of a string token
(begin (display "found char: ") (display c) (display "; added to string: ")
(set! token (string-append token (make-string 1 c)))
(display token) (newline)
(next-char (read-char f))))
((char-whitespace? c)
(begin
(display "token before ws: ") (display token) (newline)
(if (> (string-length token) 0)
(begin (call-with-current-continuation (lambda (resume)
(display "setting generate-token to resume") (newline)
(set! generate-token (lambda ()
((display "calling resume") (newline)
(resume))))
(display "yielding token from cc") (newline)
(yield token)))
(display "continuing...") (newline)
(set! token ""))
;(set! token "")
))))
(next-char (read-char f))
))))
(call-with-current-continuation (lambda (k) ((set! yield k) (k (next-char (read-char f))))))
)))
(set! lookahead (lambda () (begin
(if (not lookahead-token)
(begin (display "no lookahead") (newline)
(display "setting lookahead-token") (newline)
(set! lookahead-token (string-copy (generate-token)))
(display "lookahead set to ") (display lookahead-token) (newline)
))
lookahead-token)))
(set! next-token (lambda () (begin
(if lookahead-token
(begin (display "affirmative") (newline)
(set! current-token (string-copy lookahead-token))
(set! lookahead-token #f))
(begin (display "negative") (newline)
(display "setting current token to next-token") (newline)
(set! current-token (string-copy (generate-token)))
(display "current token = ") (display current-token) (newline)
(set! lookahead-token #f)))
current-token)))
(set! status (lambda () (begin (display current-token) (display " -> ") (display lookahead-token) (newline))))
)
Выполнение вызовов next-token и lookahead согласно первому примеру в оригинальном посте ниже приводит к получению:
> (next-token)
negative
setting current token to next-token
found char: t; added to string: t
found char: h; added to string: th
found char: e; added to string: the
found char: s; added to string: thes
found char: e; added to string: these
token before ws: these
setting generate-token to resume
yielding token from cc
current token = these
"these"
> (status)
these -> #f
> (lookahead)
no lookahead
setting lookahead-token
calling resume
continuing...
found char: a; added to string: a
found char: r; added to string: ar
found char: e; added to string: are
token before ws: are
setting generate-token to resume
yielding token from cc ; the problem is right here: the generate token call is
current token = are ; sending control back to next-token instead of lookahead.
"are"
> (status)
are -> #f
Я в недоумении, почему он так себя ведет, но признаю, что я новичок в продолжениях и, возможно, не до конца понимаю последствия. Любая помощь, как всегда, будет принята с благодарностью.
Благодарю.
Оригинальный пост следует:
Я создал генератор, который анализирует текстовый файл и возвращает один токен за раз в виде строк. Итак, если у меня есть файл, который содержит
these are my file contents
Последовательные вызовы (generate-token), возвращающие "эти", являются "моими"... соответственно. Кажется, это работает, но то, что я написал это как часть синтаксического анализатора для большего назначения. Генератор, кажется, работает бесперебойно, но, поскольку я создаю синтаксический анализатор LR(1) для анализа потока токенов, мне нужно иметь возможность выполнить предварительный просмотр. Для этого я создал следующую программу:
(define generate-token #f)
(define next-token #f)
(define lookahead #f)
(define status #f)
(let ((lookahead-token #f) (current-token #f))
(set! generate-token (lambda () ... ) ; the generator function
(set! lookahead (lambda () (begin
(if (not lookahead-token)
(begin (display "no lookahead") (newline)
(set! lookahead-token (string-copy (generate-token)))))
lookahead-token)))
(set! next-token (lambda () (begin
(if lookahead-token
(begin (display "affirmative") (newline)
(set! current-token (string-copy lookahead-token))
(set! lookahead-token #f))
(begin (display "negative") (newline)
(set! current-token (string-copy (generate-token)))
(set! lookahead-token #f)))
current-token)))
(set! status (lambda () (begin (display current-token) (display " -> ") (display lookahead-token) (newline))))
)
Тем не менее, они не работают, как ожидалось. У меня сложилось впечатление, что схема (это написано в drRacket, но с использованием #lang r5rs) передает объекты по значению, поэтому (вызовы string-copy гипотетически не нужны, но это все равно не работает так, как ожидалось.:
> (status)
#f -> #f
> (next-token)
"these"
> (status) ; next-token properly sets current-token
"these" -> #f
> (lookahead) ; generator returns "are" as expected
"are"
> (status) ; notice that the current-token has been replaced instead of the lookahead-token
"are" -> #f
В другом потоке, если (lookahead) вызывается первым, он работает правильно.
> (status)
#f -> #f
> (lookahead)
"these"
> (status)
#f -> "these"
> (lookahead)
"these"
> (status)
#f -> "these"
> (next-token)
"these"
> (status)
"these" -> #f
> (lookahead)
"are"
> (status)
"these" -> "are"
Если у кого-то есть какие-либо подсказки относительно того, что происходит, любая оценка будет принята с благодарностью. Раскрытие: это школьная работа, но я не прошу вас делать это для меня>.>.
1 ответ
Проблема заключается в вашей реализации yield, Вот упрощенная версия вашей реализации для удобства чтения:
(define yield #f)
(define my-generator
(lambda ()
(let forever ((num 0))
(let/cc resume
(set! my-generator resume)
(yield num))
(forever (add1 num)))))
(define zero (let/cc my-yield
(set! yield my-yield)
(my-generator)))
(define one (my-generator))
zero
;; => 1
Продолжение всегда возвращается обратно туда, куда первоначально возвращалось его возвращаемое значение. Так что если вы захватываете yield с call/cc или же let/ccто каждый раз yield ты прыгнешь обратно туда, где ты его захватил.
В своем коде вы потратили время, чтобы обновить свое резюме перед каждым yield, но вы только обновляете yield в одном месте, где вы собираетесь позвонить next-token, Вам необходимо обновить yield каждый раз, когда вы собираетесь позвонить generate-token,
Для тех читателей, которые не делают это для школы, просто используйте racket/generator, в котором вся работа и многое другое сделано для вас.