Как использовать Lazy Evaluation в схеме Guile?

Question

Я написал код, который использует ленивую оценку для создания бесконечной структуры данных, но есть ошибка.

Вот код:

#!/usr/bin/guile \ 
-e main -s 
!# 
(define ints-f 
    (lambda (n) 
     (let ((n1 (delay (ints-f (+ n 1))))) 
     (cons n (force n1))))) 
(define (main args) 
    (display (car (ints-f 3))) 
    (newline) 
    ) 

Это дает ошибку, которая говорит, что переполнение стека. Это означает, что сила выполняется, даже если она не вызвана. Как это исправить?

#!/usr/bin/guile \ 
-e main -s 
!# 
(define ints-f 
    (lambda (n) 
     (let ((n1 (delay (ints-f (+ n 1))))) 
     (cons n n1)))) 
(define (main args) 
    (display (car (ints-f 3))) 
    (newline) 
    ) 

Приведенный выше код дает ожидаемый выход 3, но если использовать корд, как в коде ниже

#!/usr/bin/guile \ 
-e main -s 
!# 
(define ints-f 
    (lambda (n) 
     (let ((n1 (delay (ints-f (+ n 1))))) 
     (cons n n1)))) 
(define (main args) 
    (display (cdr (ints-f 3))) 
    (newline) 
    ) 

Он печатает объект обещание.

Как использовать ленивую оценку в схеме хитрости?

Answer 1

Первый фрагмент неверен, вы вынуждаете значение при построении последовательности, следовательно, побеждая целую цель ленивой оценки. С другой стороны, второй фрагмент выглядит правильно - хотя это может быть немного упрощен:

(define (ints-f n) 
    (cons n (delay (ints-f (+ n 1))))) 

Это нормально получить обещание при вызове cdr, это преобразователь построен с delay, что только выход его значение когда force d. В самом деле, если вы хотите заглянуть в элементы бесконечной последовательности, вы должны будете использовать процедуру обхода части вы заинтересованы в:

(define (take seq n) 
    (if (= n 0) 
     '() 
     (cons (car seq) 
      (take (force (cdr seq)) (- n 1))))) 

Аналогично:

(define (get seq idx) 
    (if (= idx 0) 
     (car seq) 
     (get (force (cdr seq)) (- idx 1)))) 

Например:

(take (ints-f 5) 5) 
=> '(5 6 7 8 9) 

(get (ints-f 5) 5) 
=> 10 

Answer 2

Вы пытаетесь создать потоки? Вы можете обратиться к модулю (srfi srfi-41) для его реализации. (Раскрытие информации:. Я написал Коварство специфические части кода модуля, а все остальное было портированы из the reference implementation)

(use-modules (srfi srfi-41)) 
(define-stream (ints-f n) 
    (stream-cons n (ints-f (1+ n)))) 

Обратите внимание, что define-stream и stream-cons макросы, которые работают вместе, чтобы построить (SRFI 45 -Style) delay/force за кулисами. ^†

Пример использования:

> (stream->list 10 (ints-f 100)) 
(100 101 102 103 104 105 106 107 108 109) 

---

^† В частности, ваша функция расширяется на что-то вроде:

(define (ints-f n) 
    (lazy (eager (cons (delay n) 
        (lazy (ints-f (1+ n))))))) 

, который можно использовать с помощью:

> (define x (ints-f 100)) 
> (force (car (force x))) 
100 
> (force (car (force (cdr (force x))))) 
101