#lang racket
; Mihnea Muraru & Andrei Olaru

;(display "----- Operatori pe fluxuri -----\n")

(define-syntax-rule (pack expr)
  ;  (lambda () expr)) ; închideri
  (delay expr)) ; promisiuni

;(define unpack (λ (package) (package))) ; închideri -- package este o închidere
(define unpack force) ; promisiuni



; =====================================
(define-syntax-rule (stream-cons h t)
  (cons h (pack t)))

(define stream-car car)

(define (stream-cdr s)
  (unpack (cdr s)))

(define stream-nil '())

(define stream-null? null?)



; ===============================

(define (stream-take s n)
  (cond ((zero? n) '())
        ((stream-null? s) '())
        (else (cons (stream-car s) (stream-take (stream-cdr s) (- n 1))))))

(define (stream-drop s n)
  (cond ((zero? n) s)
        ((stream-null? s) s)
        (else (stream-drop (stream-cdr s) (- n 1)))))

(define (stream-map f s)
  (if (stream-null? s) s
      (stream-cons (f (stream-car s))
                   (stream-map f (stream-cdr s)))))

(define (stream-filter f? s)
  (cond ((stream-null? s) s)
        ((f? (stream-car s)) (stream-cons (stream-car s) (stream-filter f? (stream-cdr s))))
        (else (stream-filter f? (stream-cdr s)))))

(define (stream-zip-with f s1 s2)
  (if (stream-null? s1) s2
      (stream-cons (f (stream-car s1) (stream-car s2))
                   (stream-zip-with f (stream-cdr s1) (stream-cdr s2)))))

(define (stream-append s1 s2)
  (if (stream-null? s1) s2
      (stream-cons (stream-car s1)
                   (stream-append (stream-cdr s1) s2))))

(define (stream-assoc k s)
  (cond
    ((stream-null? s) #f)
    ((equal? (car (stream-car s)) k) (stream-car s))
    (else (stream-assoc k (stream-cdr s)))))

(define (list->stream L)
  (if (null? L) stream-nil
      (stream-cons (car L) (list->stream (cdr L)))))

; ===============================================
;(display "----- Definiri de fluxuri -----\n")



;(define ones (cons 1 ones))
;(define ones (λ () (cons 1 (ones))))
;(define ones (cons 1 (λ () ones)))
;(define ones (cons 1 (pack ones)))
(define ones (stream-cons 1 ones))

; ATENȚIE: există și în racket definit stream-cons & co, în biblioteca racket/stream.
; stream-cons din Racket întoarce un obiect de tip #<stream>

(car ones)
(cdr ones)
(equal? ones (stream-cdr ones))
(equal? ones (stream-drop ones 50))


; construcție prin funcție recursivă
;(define naturals
;  (letrec ((naturalsFrom (λ (start)
;                           (stream-cons start (naturalsFrom (add1 start))))))
;    (naturalsFrom 0)))
(define naturals
  (let naturalsFrom ((start 0))
    (stream-cons start
                 (and (display `(build from ,(add1 start))) (newline)
                      (naturalsFrom (add1 start))))))

; construcție pe baza fluxului însuși
(define naturals2 (stream-cons 0 (stream-map ((curry +) 1) naturals2)))

(define naturals3 (stream-cons 0 (stream-zip-with + ones naturals3)))


(define primes
  (let sieve ((numbers (stream-drop naturals 2)))
    (let ((prime (stream-car numbers)))
      (stream-cons prime
                   (sieve (stream-filter
                           (λ (n) (not (zero? (remainder n prime))))
                           (stream-cdr numbers)))))))

(display "primes: ")
(stream-take primes 10)

(display "1000th prime: ")
(stream-car (stream-drop primes 999))

;0 1 1 2 3 5 8 13
;1 1 2 3 5 8 13
;+
;1 2 3 5 8 13

(define fibb
  (stream-cons 0
               (stream-cons 1
                            (stream-zip-with + fibb (stream-cdr fibb)))))