Scheme 非程序调用<#不具体>；

我试图将sexps转换为xml，我有一个递归函数，它遍历表示xml标记及其子标记的列表，然后以正确的缩进将它们打印到标准输出

我正在使用鸡肉方案编译器

资料来源：

(use srfi-13)
(use extras)
;Returns the length of a list
(define (len lst)
  (define (len-help lst count)
    (cond ((not (eq? lst '())) (len-help (cdr lst) (+ count 1)))
          (else count)))
  (len-help lst 0))

  (define (const-l fil len)
  ;makes a constant list of symbol fil len times
    (cond ((> len 0) (cons fil (const-l fil (- len 1))))
          (else '())))

;makes a string out of a list of tag attribute strings
(define (make-attribute-string tag-atribs)
  (cond ((eq? tag-atribs '()) "")
        (else (string-join tag-atribs " "))))

(define (indent num)
  (string-join (const-l "  " num) ""))
;makes a tag structure from args
;tag-name is a symbol
;tag-attribs is a lis of tag attribute strings
;i.e.: '("att1='val1'" "att2='val2'")
(define (make-tag tag-label tag-atribs tag-elements)
  `(,tag-label ,(make-attribute-string tag-atribs) ,tag-elements))

(define (tag-name tag)
  (car tag))

(define (tag-atribs tag)
  (cadr tag))

(define (tag-elems tag)
  (caddr tag))

(define (print-tag tag close ind)
  (cond ((eq? close #f) (printf "~A<~A ~A>" (indent ind) (tag-name tag) (tag-atribs tag)))
        ((eq? close #t) (printf "~A<~A/>" (indent ind)(tag-name tag)))))

(define (display-heir tag)
  (define (recursive-display tag indent)
    (print-tag tag #f indent)
    (newline)
    (cond ((not (eq? (tag-elems tag) '()))
             (map (lambda (tg) (
                    (recursive-display tg (+ indent 1))))
                  (tag-elems tag))))
    (print-tag tag #t indent)
    (newline))
  (recursive-display tag 0))

(define tg3 (make-tag 'Person '("name='Joe'" "age='5'" "sex='Male'") '()))
(define tg4 (make-tag 'Person '("name='Sally'" "age='1'" "sex='Female'") '()))
(define tg2 (make-tag 'children '() (list tg3 tg4)))
(define tg1 (make-tag 'Person '("name='Bob'" "age='21'" "sex='Male'") (list tg2)))

;this doesnt work, stops working after printing first element in innermost
;level of the heirarchy, should work like the next block with some additional
;newlines
(display-heir tg1)

;this displays the tags correctly
(print-tag tg1 #f 0)
(newline)
(print-tag tg2 #f 1)
(newline)
(print-tag tg3 #f 2)(print-tag tg3 #t 0)
(newline)
(print-tag tg4 #f 2)(print-tag tg4 #t 0)
(newline)
(print-tag tg2 #t 1)
(newline)
(print-tag tg1 #t 0)

如果删除

（display heir tg1）

，它将给出正确的输出，并在该行后面显示代码：

<Person name='Bob' age='21' sex='Male'>
  <children >
    <Person name='Joe' age='5' sex='Male'><Person/>
    <Person name='Sally' age='1' sex='Female'><Person/>
  <children/>
<Person/>

这里的问题是您传递给
映射的过程：

(define (display-heir tag)
  (define (recursive-display tag indent)
    (print-tag tag #f indent)
    (newline)
    (cond ((not (eq? (tag-elems tag) '()))
             (map (lambda (tg) (
                    (recursive-display tg (+ indent 1))))
                  (tag-elems tag))))
    (print-tag tag #t indent)
    (newline))

如果缩进正确，则可以更容易地发现问题：

(define (display-heir tag)
  (define (recursive-display tag indent)
    (print-tag tag #f indent)
    (newline)
    (cond ((not (eq? (tag-elems tag) '()))
           (map (lambda (tg) (
                              (recursive-display tg (+ indent 1))))
                (tag-elems tag))))
    (print-tag tag #t indent)
    (newline))
  (recursive-display tag 0))

正如您（希望）看到的，对
递归显示的调用被包装在一组额外的括号中。这意味着它将尝试将
递归显示的结果作为过程调用（它不是，它是
void
或
#
）
这里的问题是传递给
映射的过程：

(define (display-heir tag)
  (define (recursive-display tag indent)
    (print-tag tag #f indent)
    (newline)
    (cond ((not (eq? (tag-elems tag) '()))
             (map (lambda (tg) (
                    (recursive-display tg (+ indent 1))))
                  (tag-elems tag))))
    (print-tag tag #t indent)
    (newline))

如果缩进正确，则可以更容易地发现问题：

(define (display-heir tag)
  (define (recursive-display tag indent)
    (print-tag tag #f indent)
    (newline)
    (cond ((not (eq? (tag-elems tag) '()))
           (map (lambda (tg) (
                              (recursive-display tg (+ indent 1))))
                (tag-elems tag))))
    (print-tag tag #t indent)
    (newline))
  (recursive-display tag 0))

正如您（希望）看到的，对
递归显示的调用被包装在一组额外的括号中。这意味着它将尝试将
递归显示的结果作为过程调用（它不是，它是
void
或
#
）