List 生成无限序列的无限序列格式

我在scheme中有一个项目，我需要实现一个无限的数字序列。我不能使用任何内置于复杂函数中的方案，我只是不知道如何使我的序列无限，而不会使程序在无限循环中崩溃。我不需要真正地输出它，但我需要能够使用它

(seq n)   ;;output: n,n+1,n+2,n+3.... to infinity (seq 5) ->5,6,7,8,9...

现在我做了一个序列直到n+7，但我需要这个到无穷远：

(define (seq n)
   (define (asc-order LIST counter)
     (cond ((= counter (+ n 7)) LIST)
           (else (asc-order (append LIST (cons (+ counter 1) '()))  
           (+ counter 1)))))
(asc-order '() (- n 1))
)

IO示例（它可以工作，但我需要无限序列）：

---

可以将无限序列表示为一次生成一个元素的函数。然后，用户（消费者）可以在需要序列的每个新元素时调用该函数

例如：

(define (f x) (* x x))

(define seq
  (let ()
    (define n 0)        ; current index
    (lambda ()          ; the function that is to be called repeatedly
      (define a (f n))  ;   compute the new element
      (set! n (+ n 1))  ;   compute new index
      a)))              ;   return the new element

(seq)  ; compute element 0
(seq)  ; compute element 1
(seq)  ; ...
(seq)
(seq)
(seq)

其结果是：

0
1
4
9
16
25

---

为了编写

（sequence->list sn）

来计算序列

s

的第一个

n

元素，创建一个循环，总共调用

s

次，并将结果收集到一个列表中。

您可以将无限序列表示为一次生成一个元素的函数。然后，用户（消费者）可以在需要序列的每个新元素时调用该函数

例如：

(define (f x) (* x x))

(define seq
  (let ()
    (define n 0)        ; current index
    (lambda ()          ; the function that is to be called repeatedly
      (define a (f n))  ;   compute the new element
      (set! n (+ n 1))  ;   compute new index
      a)))              ;   return the new element

(seq)  ; compute element 0
(seq)  ; compute element 1
(seq)  ; ...
(seq)
(seq)
(seq)

其结果是：

0
1
4
9
16
25

---

为了编写

（sequence->list sn）

来计算序列

s

的第一个

n

元素，创建一个循环，总共调用

s

次，并将结果收集到一个列表中。

下面是另一个使用延迟求值的解决方案：

(use-modules (ice-9 receive))


(define (seq f)
  (let loop ((n 0))
    (lambda ()
      (values (f n) (loop (1+ n))))))


(define squares (seq (lambda (x) (* x x))))

(receive (square next) (squares)
  (pk square) ;; => 0
  (receive (square next) (next)
    (pk square) ;; => 1
    (receive (square next) (next)
      (pk square) ;; => 4
      (receive (square next) (next)
        (pk square))))) ;; => 9

---

下面是另一个使用延迟评估的解决方案：

(use-modules (ice-9 receive))


(define (seq f)
  (let loop ((n 0))
    (lambda ()
      (values (f n) (loop (1+ n))))))


(define squares (seq (lambda (x) (* x x))))

(receive (square next) (squares)
  (pk square) ;; => 0
  (receive (square next) (next)
    (pk square) ;; => 1
    (receive (square next) (next)
      (pk square) ;; => 4
      (receive (square next) (next)
        (pk square))))) ;; => 9

---

关键是通过围绕列表包装一个过程来延迟对列表的评估

这是我能想到的最简单的实现。
它只是尾巴上的“懒”字

(define (seq n)
  (cons n (lambda () (seq (+ n 1)))))

(define (seq-car s)
  (car s))

(define (seq-cdr s)
  ((cdr s)))

示例用法：

; Get the 'n' first elements of 's'.
(define (seq-take n s)
  (if (<= n 0)
      '()
      (cons (seq-car s) (seq-take (- n 1) (seq-cdr s)))))


> (define s (seq 10))
> s
'(10 . #<procedure>)
> (seq-take 5 s)
'(10 11 12 13 14)

；获取“s”的“n”个前元素。
（定义（如下所示）
（如果（（顺序取5秒）
'(10 11 12 13 14)

关键是通过在列表周围包装一个过程来延迟对列表的评估

这是我能想到的最简单的实现。
它只是尾巴上的“懒”字

(define (seq n)
  (cons n (lambda () (seq (+ n 1)))))

(define (seq-car s)
  (car s))

(define (seq-cdr s)
  ((cdr s)))

示例用法：

; Get the 'n' first elements of 's'.
(define (seq-take n s)
  (if (<= n 0)
      '()
      (cons (seq-car s) (seq-take (- n 1) (seq-cdr s)))))


> (define s (seq 10))
> s
'(10 . #<procedure>)
> (seq-take 5 s)
'(10 11 12 13 14)

；获取“s”的前n个元素。
（定义（如下所示）
（如果（（顺序取5秒）
'(10 11 12 13 14)

谢谢@soegaard，但正如我提到的，我不允许使用内置的非基本函数，特别是set！谢谢@soegaard，但正如我提到的，我不允许使用内置的非基本函数，特别是set！在

take

实现中的一个常见错误是超额生产1。对于n=1，没有必要强制tail，这也可能会发散。：）在

take

实现中的一个常见错误是生产量超过1。对于n=1，没有必要强制尾部，这也可能发散。：）