How would I Implement a repeat function that would make a stream full of a repeating int?

Question

The questions is: Write a function (repeat x) which, given a value x, produces a stream that repeats x ad infinitum. For instance, the call (take (repeat 42) 5) produces (42 42 42 42 42).

My problem is that my repeat function doesn't know what to stop... so it runs forever.

This is the code I have so far.

#lang R5RS
;; Repeat your solution for take
(define (integer-stream x)
    (cons x  (delay (integer-stream (+ 1 x)))))
(define nat (integer-stream 0))

(define (stream-car stream)
  (car stream))

(define (stream-cdr stream)
  (force (cdr stream)))

(define (head stream)  (car stream))
(define (rest stream)  (force (cdr stream)))

(define (take s k)
  (cond ((= k 0) '())
        (else (cons (car s) (take (stream-cdr s) (- k 1))))))

;;;;;;;;;
(define (stream-map f s)
  (if (null? s) '()
      (cons (f (car s))
            (delay (stream-map f (rest s))))))

(define (squares x)
  (* x x))

(define (square s)
  (cond ((null? s) '())
        (else (stream-map squares s))))

;;;;;;;;;;;
(define (cubess x)
  (* x x x))

(define (cube s)
  (cond ((null? s) '())
        (else (stream-map cubess s))))

;;;;
(define (merge-streams s t)
  (cond ((null? s) t)
        ((null? t) s)
        ((< (stream-car s) (stream-car t))
         (cons (stream-car s)
               (delay (merge-streams (stream-cdr s) t))))
        (else (cons (stream-car t) (delay (merge-streams s (stream-cdr t)))))))

;;;;;

(define (repeat x)
  (cons x (repeat x)))

Answer 1

You're close- you just have to use delay in your repeat function:

(define (repeat arg)
  (cons arg (delay (repeat arg))))

Rest of code should be the same- so this will be the full code:

#lang r5rs

(define (stream-car stream)
  (car stream))

(define (stream-cdr stream)
  (force (cdr stream)))

(define (take stream n)
  (if (zero? n) '()
      (cons (stream-car stream)
            (take (stream-cdr stream) (- n 1))))) 

(define (repeat arg)
  (cons arg (delay (repeat arg))))

Test:

> (repeat 42)
(42 . #<promise>)

> (take (repeat 42) 5)
(42 42 42 42 42)