Question

我正在尝试编写一个简单的解析器，它从字符串创建一个sxml-expression，e。克。

"This is a [Test]" ===> (item "This is a" (subitem "Test"))

任何想知道给定示例中方括号的人都可以查看所谓的Leiden conventions。

这是我到目前为止编写的代码：

(define my-sequence '("this" "[" "is" "a" "]" "test"))

(define (left-square-bracket? item)
  (or (equal? item "[")
      (eq? item #\x005b)))

(define (right-square-bracket? item)
  (or (equal? item "]")
      (eq? item #\x005d)))

(define (parse-sequence sequence)
  (cond ((null? sequence) '())
        ((left-square-bracket? (car sequence))
         (let ((subsequence (get-subsequence (cdr sequence))))
           (list subsequence)))
        (else
         (cons (car sequence)
               (parse-sequence (cdr sequence))))))

(define (get-subsequence sequence)
  (if (right-square-bracket? (car sequence))
      '()
      (cons (car sequence)
            (get-subsequence (cdr sequence)))))

评估(parse-sequence my-sequence)收益率("this" ("is" "a"))。已创建嵌套表达式，但程序已完成，但未评估最后一项"test"。问题是，如何从get-subsequence返回parse-sequence？

感谢任何帮助，非常感谢提前！：）

Answer 1

要解决您的初始问题，如何返回多个值：使用“值”表单。下面是一个示例实现，其中内部过程返回要处理的剩余列表和到目前为止的结果。它在开头括号上进行了解释。

(define (parse-sequence lst)

  (define (parse-seq lst)
    (let loop ((lst lst) (res null))
      (cond
        ((null? lst) (values null res))
        ((string=? (car lst) "[")
         (let-values ([(lst2 res2) (parse-seq (cdr lst))])
           (loop lst2 (append res (list res2)))))
        ((string=? (car lst) "]")
         (values (cdr lst) res))
        (else
          (loop (cdr lst) (append res (list (car lst))))))))

  (let-values ([(lst res) (parse-seq lst)])
    res))

然后

(parse-sequence '("this" "is" "a" "test"))
(parse-sequence '("this" "[" "is" "a" "]" "test"))
(parse-sequence '("this" "[" "is" "[" "a" "]" "]" "test"))

将产生

'("this" "is" "a" "test")
'("this" ("is" "a") "test")
'("this" ("is" ("a")) "test")

Answer 2

我将open-input-string与read-char:

(define my-sequence (open-input-string "this [is a] test"))

(define (parse-sequence sequence)
  `(item
    ,@(let loop ((next-char (read-char sequence)))
        (cond ((eof-object? next-char) '())
              ((left-square-bracket? next-char)
               (let ((subsequence (get-subsequence sequence)))
                 (cons subsequence
                       (loop (read-char sequence)))))
              (else
               (cons next-char
                     (loop (read-char sequence))))))))

(define (get-subsequence sequence)
  `(subitem
    ,@(let loop ((next-char (read-char sequence)))
        (if (right-square-bracket? next-char)
            '()
            (cons next-char
                  (loop (read-char sequence)))))))

(parse-sequence my-sequence)
===> (item #\t #\h #\i #\s #\space (subitem #\i #\s #\space #\a) #\space #\t #\e #\s #\t)

结合使用取得了一些进展

现在，一步一步地继续工作。：）

仍然赞赏任何意见和建议。 :)

使用Scheme解析字符串

2 个答案: