Перезапуск продолжения схемы в странном месте

Question

UPDATE:

Таким образом, проблема, похоже, связана с генератором, а не обязательно с функциями 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"

Если кто-нибудь имеет какое-либо представление о том, что происходит, любая оценка будет принята с благодарностью. Раскрытие информации: это школьная работа, но я не прошу вас делать это для меня>.>.

Answer 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, в котором вся работа и многое другоесделано для вас.